src/libFLAC++/metadata.cpp

   1 /* libFLAC++ - Free Lossless Audio Codec library
   2  * Copyright (C) 2002,2003,2004  Josh Coalson
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  * - Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *
  11  * - Redistributions in binary form must reproduce the above copyright
  12  * notice, this list of conditions and the following disclaimer in the
  13  * documentation and/or other materials provided with the distribution.
  14  *
  15  * - Neither the name of the Xiph.org Foundation nor the names of its
  16  * contributors may be used to endorse or promote products derived from
  17  * this software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22  * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
  23  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  24  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  25  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  26  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  27  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  28  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  29  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include "FLAC++/metadata.h"
  33 #include "FLAC/assert.h"
  34 #include <stdlib.h> // for malloc(), free()
  35 #include <string.h> // for memcpy() etc.
  36
  37 namespace FLAC {
  38         namespace Metadata {
  39
  40                 // local utility routines
  41
  42                 namespace local {
  43
  44                         Prototype *construct_block(::FLAC__StreamMetadata *object)
  45                         {
  46                                 Prototype *ret = 0;
  47                                 switch(object->type) {
  48                                         case FLAC__METADATA_TYPE_STREAMINFO:
  49                                                 ret = new StreamInfo(object, /*copy=*/false);
  50                                                 break;
  51                                         case FLAC__METADATA_TYPE_PADDING:
  52                                                 ret = new Padding(object, /*copy=*/false);
  53                                                 break;
  54                                         case FLAC__METADATA_TYPE_APPLICATION:
  55                                                 ret = new Application(object, /*copy=*/false);
  56                                                 break;
  57                                         case FLAC__METADATA_TYPE_SEEKTABLE:
  58                                                 ret = new SeekTable(object, /*copy=*/false);
  59                                                 break;
  60                                         case FLAC__METADATA_TYPE_VORBIS_COMMENT:
  61                                                 ret = new VorbisComment(object, /*copy=*/false);
  62                                                 break;
  63                                         case FLAC__METADATA_TYPE_CUESHEET:
  64                                                 ret = new CueSheet(object, /*copy=*/false);
  65                                                 break;
  66                                         default:
  67                                                 ret = new Unknown(object, /*copy=*/false);
  68                                                 break;
  69                                 }
  70                                 return ret;
  71                         }
  72
  73                 };
  74
  75                 FLACPP_API Prototype *clone(const Prototype *object)
  76                 {
  77                         FLAC__ASSERT(0 != object);
  78
  79                         const StreamInfo *streaminfo = dynamic_cast<const StreamInfo *>(object);
  80                         const Padding *padding = dynamic_cast<const Padding *>(object);
  81                         const Application *application = dynamic_cast<const Application *>(object);
  82                         const SeekTable *seektable = dynamic_cast<const SeekTable *>(object);
  83                         const VorbisComment *vorbiscomment = dynamic_cast<const VorbisComment *>(object);
  84                         const CueSheet *cuesheet = dynamic_cast<const CueSheet *>(object);
  85                         const Unknown *unknown = dynamic_cast<const Unknown *>(object);
  86
  87                         if(0 != streaminfo)
  88                                 return new StreamInfo(*streaminfo);
  89                         else if(0 != padding)
  90                                 return new Padding(*padding);
  91                         else if(0 != application)
  92                                 return new Application(*application);
  93                         else if(0 != seektable)
  94                                 return new SeekTable(*seektable);
  95                         else if(0 != vorbiscomment)
  96                                 return new VorbisComment(*vorbiscomment);
  97                         else if(0 != cuesheet)
  98                                 return new CueSheet(*cuesheet);
  99                         else if(0 != unknown)
 100                                 return new Unknown(*unknown);
 101                         else {
 102                                 FLAC__ASSERT(0);
 103                                 return 0;
 104                         }
 105                 }
 106
 107                 //
 108                 // Prototype
 109                 //
 110
 111                 Prototype::Prototype(const Prototype &object):
 112                 object_(::FLAC__metadata_object_clone(object.object_)),
 113                 is_reference_(false)
 114                 {
 115                         FLAC__ASSERT(object.is_valid());
 116                 }
 117
 118                 Prototype::Prototype(const ::FLAC__StreamMetadata &object):
 119                 object_(::FLAC__metadata_object_clone(&object)),
 120                 is_reference_(false)
 121                 {
 122                 }
 123
 124                 Prototype::Prototype(const ::FLAC__StreamMetadata *object):
 125                 object_(::FLAC__metadata_object_clone(object)),
 126                 is_reference_(false)
 127                 {
 128                         FLAC__ASSERT(0 != object);
 129                 }
 130
 131                 Prototype::Prototype(::FLAC__StreamMetadata *object, bool copy):
 132                 object_(copy? ::FLAC__metadata_object_clone(object) : object),
 133                 is_reference_(false)
 134                 {
 135                         FLAC__ASSERT(0 != object);
 136                 }
 137
 138                 Prototype::~Prototype()
 139                 {
 140                         clear();
 141                 }
 142
 143                 void Prototype::clear()
 144                 {
 145                         if(0 != object_ && !is_reference_)
 146                                 FLAC__metadata_object_delete(object_);
 147                         object_ = 0;
 148                 }
 149
 150                 void Prototype::operator=(const Prototype &object)
 151                 {
 152                         FLAC__ASSERT(object.is_valid());
 153                         clear();
 154                         is_reference_ = false;
 155                         object_ = ::FLAC__metadata_object_clone(object.object_);
 156                 }
 157
 158                 void Prototype::operator=(const ::FLAC__StreamMetadata &object)
 159                 {
 160                         clear();
 161                         is_reference_ = false;
 162                         object_ = ::FLAC__metadata_object_clone(&object);
 163                 }
 164
 165                 void Prototype::operator=(const ::FLAC__StreamMetadata *object)
 166                 {
 167                         FLAC__ASSERT(0 != object);
 168                         clear();
 169                         is_reference_ = false;
 170                         object_ = ::FLAC__metadata_object_clone(object);
 171                 }
 172
 173                 bool Prototype::get_is_last() const
 174                 {
 175                         FLAC__ASSERT(is_valid());
 176                         return (bool)object_->is_last;
 177                 }
 178
 179                 FLAC__MetadataType Prototype::get_type() const
 180                 {
 181                         FLAC__ASSERT(is_valid());
 182                         return object_->type;
 183                 }
 184
 185                 unsigned Prototype::get_length() const
 186                 {
 187                         FLAC__ASSERT(is_valid());
 188                         return object_->length;
 189                 }
 190
 191                 void Prototype::set_is_last(bool value)
 192                 {
 193                         FLAC__ASSERT(is_valid());
 194                         object_->is_last = value;
 195                 }
 196
 197
 198                 //
 199                 // StreamInfo
 200                 //
 201
 202                 StreamInfo::StreamInfo():
 203                 Prototype(FLAC__metadata_object_new(FLAC__METADATA_TYPE_STREAMINFO), /*copy=*/false)
 204                 { }
 205
 206                 StreamInfo::~StreamInfo()
 207                 { }
 208
 209                 unsigned StreamInfo::get_min_blocksize() const
 210                 {
 211                         FLAC__ASSERT(is_valid());
 212                         return object_->data.stream_info.min_blocksize;
 213                 }
 214
 215                 unsigned StreamInfo::get_max_blocksize() const
 216                 {
 217                         FLAC__ASSERT(is_valid());
 218                         return object_->data.stream_info.max_blocksize;
 219                 }
 220
 221                 unsigned StreamInfo::get_min_framesize() const
 222                 {
 223                         FLAC__ASSERT(is_valid());
 224                         return object_->data.stream_info.min_framesize;
 225                 }
 226
 227                 unsigned StreamInfo::get_max_framesize() const
 228                 {
 229                         FLAC__ASSERT(is_valid());
 230                         return object_->data.stream_info.max_framesize;
 231                 }
 232
 233                 unsigned StreamInfo::get_sample_rate() const
 234                 {
 235                         FLAC__ASSERT(is_valid());
 236                         return object_->data.stream_info.sample_rate;
 237                 }
 238
 239                 unsigned StreamInfo::get_channels() const
 240                 {
 241                         FLAC__ASSERT(is_valid());
 242                         return object_->data.stream_info.channels;
 243                 }
 244
 245                 unsigned StreamInfo::get_bits_per_sample() const
 246                 {
 247                         FLAC__ASSERT(is_valid());
 248                         return object_->data.stream_info.bits_per_sample;
 249                 }
 250
 251                 FLAC__uint64 StreamInfo::get_total_samples() const
 252                 {
 253                         FLAC__ASSERT(is_valid());
 254                         return object_->data.stream_info.total_samples;
 255                 }
 256
 257                 const FLAC__byte *StreamInfo::get_md5sum() const
 258                 {
 259                         FLAC__ASSERT(is_valid());
 260                         return object_->data.stream_info.md5sum;
 261                 }
 262
 263                 void StreamInfo::set_min_blocksize(unsigned value)
 264                 {
 265                         FLAC__ASSERT(is_valid());
 266                         FLAC__ASSERT(value >= FLAC__MIN_BLOCK_SIZE);
 267                         FLAC__ASSERT(value <= FLAC__MAX_BLOCK_SIZE);
 268                         object_->data.stream_info.min_blocksize = value;
 269                 }
 270
 271                 void StreamInfo::set_max_blocksize(unsigned value)
 272                 {
 273                         FLAC__ASSERT(is_valid());
 274                         FLAC__ASSERT(value >= FLAC__MIN_BLOCK_SIZE);
 275                         FLAC__ASSERT(value <= FLAC__MAX_BLOCK_SIZE);
 276                         object_->data.stream_info.max_blocksize = value;
 277                 }
 278
 279                 void StreamInfo::set_min_framesize(unsigned value)
 280                 {
 281                         FLAC__ASSERT(is_valid());
 282                         FLAC__ASSERT(value < (1u < FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN));
 283                         object_->data.stream_info.min_framesize = value;
 284                 }
 285
 286                 void StreamInfo::set_max_framesize(unsigned value)
 287                 {
 288                         FLAC__ASSERT(is_valid());
 289                         FLAC__ASSERT(value < (1u < FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN));
 290                         object_->data.stream_info.max_framesize = value;
 291                 }
 292
 293                 void StreamInfo::set_sample_rate(unsigned value)
 294                 {
 295                         FLAC__ASSERT(is_valid());
 296                         FLAC__ASSERT(FLAC__format_sample_rate_is_valid(value));
 297                         object_->data.stream_info.sample_rate = value;
 298                 }
 299
 300                 void StreamInfo::set_channels(unsigned value)
 301                 {
 302                         FLAC__ASSERT(is_valid());
 303                         FLAC__ASSERT(value > 0);
 304                         FLAC__ASSERT(value <= FLAC__MAX_CHANNELS);
 305                         object_->data.stream_info.channels = value;
 306                 }
 307
 308                 void StreamInfo::set_bits_per_sample(unsigned value)
 309                 {
 310                         FLAC__ASSERT(is_valid());
 311                         FLAC__ASSERT(value >= FLAC__MIN_BITS_PER_SAMPLE);
 312                         FLAC__ASSERT(value <= FLAC__MAX_BITS_PER_SAMPLE);
 313                         object_->data.stream_info.bits_per_sample = value;
 314                 }
 315
 316                 void StreamInfo::set_total_samples(FLAC__uint64 value)
 317                 {
 318                         FLAC__ASSERT(is_valid());
 319                         FLAC__ASSERT(value < (1u << FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN));
 320                         object_->data.stream_info.total_samples = value;
 321                 }
 322
 323                 void StreamInfo::set_md5sum(const FLAC__byte value[16])
 324                 {
 325                         FLAC__ASSERT(is_valid());
 326                         FLAC__ASSERT(0 != value);
 327                         memcpy(object_->data.stream_info.md5sum, value, 16);
 328                 }
 329
 330
 331                 //
 332                 // Padding
 333                 //
 334
 335                 Padding::Padding():
 336                 Prototype(FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING), /*copy=*/false)
 337                 { }
 338
 339                 Padding::~Padding()
 340                 { }
 341
 342                 void Padding::set_length(unsigned length)
 343                 {
 344                         FLAC__ASSERT(is_valid());
 345                         object_->length = length;
 346                 }
 347
 348
 349                 //
 350                 // Application
 351                 //
 352
 353                 Application::Application():
 354                 Prototype(FLAC__metadata_object_new(FLAC__METADATA_TYPE_APPLICATION), /*copy=*/false)
 355                 { }
 356
 357                 Application::~Application()
 358                 { }
 359
 360                 const FLAC__byte *Application::get_id() const
 361                 {
 362                         FLAC__ASSERT(is_valid());
 363                         return object_->data.application.id;
 364                 }
 365
 366                 const FLAC__byte *Application::get_data() const
 367                 {
 368                         FLAC__ASSERT(is_valid());
 369                         return object_->data.application.data;
 370                 }
 371
 372                 void Application::set_id(const FLAC__byte value[4])
 373                 {
 374                         FLAC__ASSERT(is_valid());
 375                         FLAC__ASSERT(0 != value);
 376                         memcpy(object_->data.application.id, value, 4);
 377                 }
 378
 379                 bool Application::set_data(const FLAC__byte *data, unsigned length)
 380                 {
 381                         FLAC__ASSERT(is_valid());
 382                         return (bool)::FLAC__metadata_object_application_set_data(object_, (FLAC__byte*)data, length, true);
 383                 }
 384
 385                 bool Application::set_data(FLAC__byte *data, unsigned length, bool copy)
 386                 {
 387                         FLAC__ASSERT(is_valid());
 388                         return (bool)::FLAC__metadata_object_application_set_data(object_, data, length, copy);
 389                 }
 390
 391
 392                 //
 393                 // SeekTable
 394                 //
 395
 396                 SeekTable::SeekTable():
 397                 Prototype(FLAC__metadata_object_new(FLAC__METADATA_TYPE_SEEKTABLE), /*copy=*/false)
 398                 { }
 399
 400                 SeekTable::~SeekTable()
 401                 { }
 402
 403                 unsigned SeekTable::get_num_points() const
 404                 {
 405                         FLAC__ASSERT(is_valid());
 406                         return object_->data.seek_table.num_points;
 407                 }
 408
 409                 ::FLAC__StreamMetadata_SeekPoint SeekTable::get_point(unsigned index) const
 410                 {
 411                         FLAC__ASSERT(is_valid());
 412                         FLAC__ASSERT(index < object_->data.seek_table.num_points);
 413                         return object_->data.seek_table.points[index];
 414                 }
 415
 416                 void SeekTable::set_point(unsigned index, const ::FLAC__StreamMetadata_SeekPoint &point)
 417                 {
 418                         FLAC__ASSERT(is_valid());
 419                         FLAC__ASSERT(index < object_->data.seek_table.num_points);
 420                         ::FLAC__metadata_object_seektable_set_point(object_, index, point);
 421                 }
 422
 423                 bool SeekTable::insert_point(unsigned index, const ::FLAC__StreamMetadata_SeekPoint &point)
 424                 {
 425                         FLAC__ASSERT(is_valid());
 426                         FLAC__ASSERT(index <= object_->data.seek_table.num_points);
 427                         return (bool)::FLAC__metadata_object_seektable_insert_point(object_, index, point);
 428                 }
 429
 430                 bool SeekTable::delete_point(unsigned index)
 431                 {
 432                         FLAC__ASSERT(is_valid());
 433                         FLAC__ASSERT(index < object_->data.seek_table.num_points);
 434                         return (bool)::FLAC__metadata_object_seektable_delete_point(object_, index);
 435                 }
 436
 437                 bool SeekTable::is_legal() const
 438                 {
 439                         FLAC__ASSERT(is_valid());
 440                         return (bool)::FLAC__metadata_object_seektable_is_legal(object_);
 441                 }
 442
 443
 444                 //
 445                 // VorbisComment::Entry
 446                 //
 447
 448                 VorbisComment::Entry::Entry()
 449                 {
 450                         zero();
 451                 }
 452
 453                 VorbisComment::Entry::Entry(const char *field, unsigned field_length)
 454                 {
 455                         zero();
 456                         construct(field, field_length);
 457                 }
 458
 459                 VorbisComment::Entry::Entry(const char *field_name, const char *field_value, unsigned field_value_length)
 460                 {
 461                         zero();
 462                         construct(field_name, field_value, field_value_length);
 463                 }
 464
 465                 VorbisComment::Entry::Entry(const Entry &entry)
 466                 {
 467                         FLAC__ASSERT(entry.is_valid());
 468                         zero();
 469                         construct((const char *)entry.entry_.entry, entry.entry_.length);
 470                 }
 471
 472                 void VorbisComment::Entry::operator=(const Entry &entry)
 473                 {
 474                         FLAC__ASSERT(entry.is_valid());
 475                         clear();
 476                         construct((const char *)entry.entry_.entry, entry.entry_.length);
 477                 }
 478
 479                 VorbisComment::Entry::~Entry()
 480                 {
 481                         clear();
 482                 }
 483
 484                 bool VorbisComment::Entry::is_valid() const
 485                 {
 486                         return is_valid_;
 487                 }
 488
 489                 unsigned VorbisComment::Entry::get_field_length() const
 490                 {
 491                         FLAC__ASSERT(is_valid());
 492                         return entry_.length;
 493                 }
 494
 495                 unsigned VorbisComment::Entry::get_field_name_length() const
 496                 {
 497                         FLAC__ASSERT(is_valid());
 498                         return field_name_length_;
 499                 }
 500
 501                 unsigned VorbisComment::Entry::get_field_value_length() const
 502                 {
 503                         FLAC__ASSERT(is_valid());
 504                         return field_value_length_;
 505                 }
 506
 507                 ::FLAC__StreamMetadata_VorbisComment_Entry VorbisComment::Entry::get_entry() const
 508                 {
 509                         FLAC__ASSERT(is_valid());
 510                         return entry_;
 511                 }
 512
 513                 const char *VorbisComment::Entry::get_field() const
 514                 {
 515                         FLAC__ASSERT(is_valid());
 516                         return (const char *)entry_.entry;
 517                 }
 518
 519                 const char *VorbisComment::Entry::get_field_name() const
 520                 {
 521                         FLAC__ASSERT(is_valid());
 522                         return field_name_;
 523                 }
 524
 525                 const char *VorbisComment::Entry::get_field_value() const
 526                 {
 527                         FLAC__ASSERT(is_valid());
 528                         return field_value_;
 529                 }
 530
 531                 bool VorbisComment::Entry::set_field(const char *field, unsigned field_length)
 532                 {
 533                         FLAC__ASSERT(is_valid());
 534                         FLAC__ASSERT(0 != field);
 535
 536                         clear_entry();
 537
 538                         if(0 == (entry_.entry = (FLAC__byte*)malloc(field_length))) {
 539                                 is_valid_ = false;
 540                         }
 541                         else {
 542                                 entry_.length = field_length;
 543                                 memcpy(entry_.entry, field, field_length);
 544                                 (void) parse_field();
 545                         }
 546
 547                         return is_valid_;
 548                 }
 549
 550                 bool VorbisComment::Entry::set_field_name(const char *field_name)
 551                 {
 552                         FLAC__ASSERT(is_valid());
 553                         FLAC__ASSERT(0 != field_name);
 554
 555                         clear_field_name();
 556
 557                         if(0 == (field_name_ = strdup(field_name))) {
 558                                 is_valid_ = false;
 559                         }
 560                         else {
 561                                 field_name_length_ = strlen(field_name_);
 562                                 compose_field();
 563                         }
 564
 565                         return is_valid_;
 566                 }
 567
 568                 bool VorbisComment::Entry::set_field_value(const char *field_value, unsigned field_value_length)
 569                 {
 570                         FLAC__ASSERT(is_valid());
 571                         FLAC__ASSERT(0 != field_value);
 572
 573                         clear_field_value();
 574
 575                         if(0 == (field_value_ = (char *)malloc(field_value_length))) {
 576                                 is_valid_ = false;
 577                         }
 578                         else {
 579                                 field_value_length_ = field_value_length;
 580                                 memcpy(field_value_, field_value, field_value_length);
 581                                 compose_field();
 582                         }
 583
 584                         return is_valid_;
 585                 }
 586
 587                 void VorbisComment::Entry::zero()
 588                 {
 589                         is_valid_ = true;
 590                         entry_.length = 0;
 591                         entry_.entry = 0;
 592                         field_name_ = 0;
 593                         field_name_length_ = 0;
 594                         field_value_ = 0;
 595                         field_value_length_ = 0;
 596                 }
 597
 598                 void VorbisComment::Entry::clear()
 599                 {
 600                         clear_entry();
 601                         clear_field_name();
 602                         clear_field_value();
 603                         is_valid_ = true;
 604                 }
 605
 606                 void VorbisComment::Entry::clear_entry()
 607                 {
 608                         if(0 != entry_.entry) {
 609                                 free(entry_.entry);
 610                                 entry_.entry = 0;
 611                                 entry_.length = 0;
 612                         }
 613                 }
 614
 615                 void VorbisComment::Entry::clear_field_name()
 616                 {
 617                         if(0 != field_name_) {
 618                                 free(field_name_);
 619                                 field_name_ = 0;
 620                                 field_name_length_ = 0;
 621                         }
 622                 }
 623
 624                 void VorbisComment::Entry::clear_field_value()
 625                 {
 626                         if(0 != field_value_) {
 627                                 free(field_value_);
 628                                 field_value_ = 0;
 629                                 field_value_length_ = 0;
 630                         }
 631                 }
 632
 633                 void VorbisComment::Entry::construct(const char *field, unsigned field_length)
 634                 {
 635                         if(set_field(field, field_length))
 636                                 parse_field();
 637                 }
 638
 639                 void VorbisComment::Entry::construct(const char *field_name, const char *field_value, unsigned field_value_length)
 640                 {
 641                         if(set_field_name(field_name) && set_field_value(field_value, field_value_length))
 642                                 compose_field();
 643                 }
 644
 645                 void VorbisComment::Entry::compose_field()
 646                 {
 647                         clear_entry();
 648
 649                         if(0 == (entry_.entry = (FLAC__byte*)malloc(field_name_length_ + 1 + field_value_length_))) {
 650                                 is_valid_ = false;
 651                         }
 652                         else {
 653                                 memcpy(entry_.entry, field_name_, field_name_length_);
 654                                 entry_.length += field_name_length_;
 655                                 memcpy(entry_.entry + entry_.length, "=", 1);
 656                                 entry_.length += 1;
 657                                 memcpy(entry_.entry + entry_.length, field_value_, field_value_length_);
 658                                 entry_.length += field_value_length_;
 659                                 is_valid_ = true;
 660                         }
 661                 }
 662
 663                 void VorbisComment::Entry::parse_field()
 664                 {
 665                         clear_field_name();
 666                         clear_field_value();
 667
 668                         const char *p = (const char *)memchr(entry_.entry, '=', entry_.length);
 669
 670                         if(0 == p)
 671                                 p = (const char *)entry_.entry + entry_.length;
 672
 673                         field_name_length_ = p - (const char *)entry_.entry;
 674                         if(0 == (field_name_ = (char *)malloc(field_name_length_ + 1))) { // +1 for the trailing \0
 675                                 is_valid_ = false;
 676                                 return;
 677                         }
 678                         memcpy(field_name_, entry_.entry, field_name_length_);
 679                         field_name_[field_name_length_] = '\0';
 680
 681                         if(entry_.length - field_name_length_ == 0) {
 682                                 field_value_length_ = 0;
 683                                 if(0 == (field_value_ = (char *)malloc(0))) {
 684                                         is_valid_ = false;
 685                                         return;
 686                                 }
 687                         }
 688                         else {
 689                                 field_value_length_ = entry_.length - field_name_length_ - 1;
 690                                 if(0 == (field_value_ = (char *)malloc(field_value_length_))) {
 691                                         is_valid_ = false;
 692                                         return;
 693                                 }
 694                                 memcpy(field_value_, ++p, field_value_length_);
 695                         }
 696
 697                         is_valid_ = true;
 698                 }
 699
 700
 701                 //
 702                 // VorbisComment
 703                 //
 704
 705                 VorbisComment::VorbisComment():
 706                 Prototype(FLAC__metadata_object_new(FLAC__METADATA_TYPE_VORBIS_COMMENT), /*copy=*/false)
 707                 { }
 708
 709                 VorbisComment::~VorbisComment()
 710                 { }
 711
 712                 unsigned VorbisComment::get_num_comments() const
 713                 {
 714                         FLAC__ASSERT(is_valid());
 715                         return object_->data.vorbis_comment.num_comments;
 716                 }
 717
 718                 VorbisComment::Entry VorbisComment::get_vendor_string() const
 719                 {
 720                         FLAC__ASSERT(is_valid());
 721                         return Entry((const char *)object_->data.vorbis_comment.vendor_string.entry, object_->data.vorbis_comment.vendor_string.length);
 722                 }
 723
 724                 VorbisComment::Entry VorbisComment::get_comment(unsigned index) const
 725                 {
 726                         FLAC__ASSERT(is_valid());
 727                         FLAC__ASSERT(index < object_->data.vorbis_comment.num_comments);
 728                         return Entry((const char *)object_->data.vorbis_comment.comments[index].entry, object_->data.vorbis_comment.comments[index].length);
 729                 }
 730
 731                 bool VorbisComment::set_vendor_string(const VorbisComment::Entry &entry)
 732                 {
 733                         FLAC__ASSERT(is_valid());
 734                         // vendor_string is a special kind of entry
 735                         ::FLAC__StreamMetadata_VorbisComment_Entry vendor_string;
 736                         vendor_string.length = entry.get_field_name_length();
 737                         vendor_string.entry = (FLAC__byte*)entry.get_field_name(); // we can cheat on const-ness because we make a copy below:
 738                         return (bool)::FLAC__metadata_object_vorbiscomment_set_vendor_string(object_, vendor_string, /*copy=*/true);
 739                 }
 740
 741                 bool VorbisComment::set_comment(unsigned index, const VorbisComment::Entry &entry)
 742                 {
 743                         FLAC__ASSERT(is_valid());
 744                         FLAC__ASSERT(index < object_->data.vorbis_comment.num_comments);
 745                         return (bool)::FLAC__metadata_object_vorbiscomment_set_comment(object_, index, entry.get_entry(), /*copy=*/true);
 746                 }
 747
 748                 bool VorbisComment::insert_comment(unsigned index, const VorbisComment::Entry &entry)
 749                 {
 750                         FLAC__ASSERT(is_valid());
 751                         FLAC__ASSERT(index <= object_->data.vorbis_comment.num_comments);
 752                         return (bool)::FLAC__metadata_object_vorbiscomment_insert_comment(object_, index, entry.get_entry(), /*copy=*/true);
 753                 }
 754
 755                 bool VorbisComment::delete_comment(unsigned index)
 756                 {
 757                         FLAC__ASSERT(is_valid());
 758                         FLAC__ASSERT(index < object_->data.vorbis_comment.num_comments);
 759                         return (bool)::FLAC__metadata_object_vorbiscomment_delete_comment(object_, index);
 760                 }
 761
 762
 763                 //
 764                 // CueSheet::Track
 765                 //
 766
 767                 CueSheet::Track::Track():
 768                 object_(::FLAC__metadata_object_cuesheet_track_new())
 769                 { }
 770
 771                 CueSheet::Track::Track(const ::FLAC__StreamMetadata_CueSheet_Track *track):
 772                 object_(::FLAC__metadata_object_cuesheet_track_clone(track))
 773                 { }
 774
 775                 CueSheet::Track::Track(const Track &track):
 776                 object_(::FLAC__metadata_object_cuesheet_track_clone(track.object_))
 777                 { }
 778
 779                 void CueSheet::Track::operator=(const Track &track)
 780                 {
 781                         if(0 != object_)
 782                                 ::FLAC__metadata_object_cuesheet_track_delete(object_);
 783                         object_ = ::FLAC__metadata_object_cuesheet_track_clone(track.object_);
 784                 }
 785
 786                 CueSheet::Track::~Track()
 787                 {
 788                         if(0 != object_)
 789                                 ::FLAC__metadata_object_cuesheet_track_delete(object_);
 790                 }
 791
 792                 bool CueSheet::Track::is_valid() const
 793                 {
 794                         return(0 != object_);
 795                 }
 796
 797                 ::FLAC__StreamMetadata_CueSheet_Index CueSheet::Track::get_index(unsigned i) const
 798                 {
 799                         FLAC__ASSERT(is_valid());
 800                         FLAC__ASSERT(i < object_->num_indices);
 801                         return object_->indices[i];
 802                 }
 803
 804                 void CueSheet::Track::set_isrc(const char value[12])
 805                 {
 806                         FLAC__ASSERT(is_valid());
 807                         FLAC__ASSERT(0 != value);
 808                         memcpy(object_->isrc, value, 12);
 809                         object_->isrc[12] = '\0';
 810                 }
 811
 812                 void CueSheet::Track::set_type(unsigned value)
 813                 {
 814                         FLAC__ASSERT(is_valid());
 815                         FLAC__ASSERT(value <= 1);
 816                         object_->type = value;
 817                 }
 818
 819                 void CueSheet::Track::set_index(unsigned i, const ::FLAC__StreamMetadata_CueSheet_Index &index)
 820                 {
 821                         FLAC__ASSERT(is_valid());
 822                         FLAC__ASSERT(i < object_->num_indices);
 823                         object_->indices[i] = index;
 824                 }
 825
 826
 827                 //
 828                 // CueSheet
 829                 //
 830
 831                 CueSheet::CueSheet():
 832                 Prototype(FLAC__metadata_object_new(FLAC__METADATA_TYPE_CUESHEET), /*copy=*/false)
 833                 { }
 834
 835                 CueSheet::~CueSheet()
 836                 { }
 837
 838                 const char *CueSheet::get_media_catalog_number() const
 839                 {
 840                         FLAC__ASSERT(is_valid());
 841                         return object_->data.cue_sheet.media_catalog_number;
 842                 }
 843
 844                 FLAC__uint64 CueSheet::get_lead_in() const
 845                 {
 846                         FLAC__ASSERT(is_valid());
 847                         return object_->data.cue_sheet.lead_in;
 848                 }
 849
 850                 bool CueSheet::get_is_cd() const
 851                 {
 852                         FLAC__ASSERT(is_valid());
 853                         return object_->data.cue_sheet.is_cd? true : false;
 854                 }
 855
 856                 unsigned CueSheet::get_num_tracks() const
 857                 {
 858                         FLAC__ASSERT(is_valid());
 859                         return object_->data.cue_sheet.num_tracks;
 860                 }
 861
 862                 CueSheet::Track CueSheet::get_track(unsigned i) const
 863                 {
 864                         FLAC__ASSERT(is_valid());
 865                         FLAC__ASSERT(i < object_->data.cue_sheet.num_tracks);
 866                         return Track(object_->data.cue_sheet.tracks + i);
 867                 }
 868
 869                 void CueSheet::set_media_catalog_number(const char value[128])
 870                 {
 871                         FLAC__ASSERT(is_valid());
 872                         FLAC__ASSERT(0 != value);
 873                         memcpy(object_->data.cue_sheet.media_catalog_number, value, 128);
 874                         object_->data.cue_sheet.media_catalog_number[128] = '\0';
 875                 }
 876
 877                 void CueSheet::set_lead_in(FLAC__uint64 value)
 878                 {
 879                         FLAC__ASSERT(is_valid());
 880                         object_->data.cue_sheet.lead_in = value;
 881                 }
 882
 883                 void CueSheet::set_is_cd(bool value)
 884                 {
 885                         FLAC__ASSERT(is_valid());
 886                         object_->data.cue_sheet.is_cd = value;
 887                 }
 888
 889                 void CueSheet::set_index(unsigned track_num, unsigned index_num, const ::FLAC__StreamMetadata_CueSheet_Index &index)
 890                 {
 891                         FLAC__ASSERT(is_valid());
 892                         FLAC__ASSERT(track_num < object_->data.cue_sheet.num_tracks);
 893                         FLAC__ASSERT(index_num < object_->data.cue_sheet.tracks[track_num].num_indices);
 894                         object_->data.cue_sheet.tracks[track_num].indices[index_num] = index;
 895                 }
 896
 897                 bool CueSheet::insert_index(unsigned track_num, unsigned index_num, const ::FLAC__StreamMetadata_CueSheet_Index &index)
 898                 {
 899                         FLAC__ASSERT(is_valid());
 900                         FLAC__ASSERT(track_num < object_->data.cue_sheet.num_tracks);
 901                         FLAC__ASSERT(index_num <= object_->data.cue_sheet.tracks[track_num].num_indices);
 902                         return (bool)::FLAC__metadata_object_cuesheet_track_insert_index(object_, track_num, index_num, index);
 903                 }
 904
 905                 bool CueSheet::delete_index(unsigned track_num, unsigned index_num)
 906                 {
 907                         FLAC__ASSERT(is_valid());
 908                         FLAC__ASSERT(track_num < object_->data.cue_sheet.num_tracks);
 909                         FLAC__ASSERT(index_num < object_->data.cue_sheet.tracks[track_num].num_indices);
 910                         return (bool)::FLAC__metadata_object_cuesheet_track_delete_index(object_, track_num, index_num);
 911                 }
 912
 913                 bool CueSheet::set_track(unsigned i, const CueSheet::Track &track)
 914                 {
 915                         FLAC__ASSERT(is_valid());
 916                         FLAC__ASSERT(i < object_->data.cue_sheet.num_tracks);
 917                         // We can safely const_cast since copy=true
 918                         return (bool)::FLAC__metadata_object_cuesheet_set_track(object_, i, const_cast< ::FLAC__StreamMetadata_CueSheet_Track*>(track.get_track()), /*copy=*/true);
 919                 }
 920
 921                 bool CueSheet::insert_track(unsigned i, const CueSheet::Track &track)
 922                 {
 923                         FLAC__ASSERT(is_valid());
 924                         FLAC__ASSERT(i <= object_->data.cue_sheet.num_tracks);
 925                         // We can safely const_cast since copy=true
 926                         return (bool)::FLAC__metadata_object_cuesheet_insert_track(object_, i, const_cast< ::FLAC__StreamMetadata_CueSheet_Track*>(track.get_track()), /*copy=*/true);
 927                 }
 928
 929                 bool CueSheet::delete_track(unsigned i)
 930                 {
 931                         FLAC__ASSERT(is_valid());
 932                         FLAC__ASSERT(i < object_->data.cue_sheet.num_tracks);
 933                         return (bool)::FLAC__metadata_object_cuesheet_delete_track(object_, i);
 934                 }
 935
 936                 bool CueSheet::is_legal(bool check_cd_da_subset, const char **violation) const
 937                 {
 938                         FLAC__ASSERT(is_valid());
 939                         return (bool)::FLAC__metadata_object_cuesheet_is_legal(object_, check_cd_da_subset, violation);
 940                 }
 941
 942
 943                 //
 944                 // Unknown
 945                 //
 946
 947                 Unknown::Unknown():
 948                 Prototype(FLAC__metadata_object_new(FLAC__METADATA_TYPE_APPLICATION), /*copy=*/false)
 949                 { }
 950
 951                 Unknown::~Unknown()
 952                 { }
 953
 954                 const FLAC__byte *Unknown::get_data() const
 955                 {
 956                         FLAC__ASSERT(is_valid());
 957                         return object_->data.application.data;
 958                 }
 959
 960                 bool Unknown::set_data(const FLAC__byte *data, unsigned length)
 961                 {
 962                         FLAC__ASSERT(is_valid());
 963                         return (bool)::FLAC__metadata_object_application_set_data(object_, (FLAC__byte*)data, length, true);
 964                 }
 965
 966                 bool Unknown::set_data(FLAC__byte *data, unsigned length, bool copy)
 967                 {
 968                         FLAC__ASSERT(is_valid());
 969                         return (bool)::FLAC__metadata_object_application_set_data(object_, data, length, copy);
 970                 }
 971
 972
 973                 // ============================================================
 974                 //
 975                 //  Level 0
 976                 //
 977                 // ============================================================
 978
 979                 FLACPP_API bool get_streaminfo(const char *filename, StreamInfo &streaminfo)
 980                 {
 981                         FLAC__ASSERT(0 != filename);
 982
 983                         ::FLAC__StreamMetadata s;
 984
 985                         if(::FLAC__metadata_get_streaminfo(filename, &s)) {
 986                                 streaminfo = s;
 987                                 return true;
 988                         }
 989                         else
 990                                 return false;
 991                 }
 992
 993
 994                 // ============================================================
 995                 //
 996                 //  Level 1
 997                 //
 998                 // ============================================================
 999
1000                 SimpleIterator::SimpleIterator():
1001                 iterator_(::FLAC__metadata_simple_iterator_new())
1002                 { }
1003
1004                 SimpleIterator::~SimpleIterator()
1005                 {
1006                         clear();
1007                 }
1008
1009                 void SimpleIterator::clear()
1010                 {
1011                         if(0 != iterator_)
1012                                 FLAC__metadata_simple_iterator_delete(iterator_);
1013                         iterator_ = 0;
1014                 }
1015
1016                 bool SimpleIterator::init(const char *filename, bool read_only, bool preserve_file_stats)
1017                 {
1018                         FLAC__ASSERT(0 != filename);
1019                         FLAC__ASSERT(is_valid());
1020                         return (bool)::FLAC__metadata_simple_iterator_init(iterator_, filename, read_only, preserve_file_stats);
1021                 }
1022
1023                 bool SimpleIterator::is_valid() const
1024                 {
1025                         return 0 != iterator_;
1026                 }
1027
1028                 SimpleIterator::Status SimpleIterator::status()
1029                 {
1030                         FLAC__ASSERT(is_valid());
1031                         return Status(::FLAC__metadata_simple_iterator_status(iterator_));
1032                 }
1033
1034                 bool SimpleIterator::is_writable() const
1035                 {
1036                         FLAC__ASSERT(is_valid());
1037                         return (bool)::FLAC__metadata_simple_iterator_is_writable(iterator_);
1038                 }
1039
1040                 bool SimpleIterator::next()
1041                 {
1042                         FLAC__ASSERT(is_valid());
1043                         return (bool)::FLAC__metadata_simple_iterator_next(iterator_);
1044                 }
1045
1046                 bool SimpleIterator::prev()
1047                 {
1048                         FLAC__ASSERT(is_valid());
1049                         return (bool)::FLAC__metadata_simple_iterator_prev(iterator_);
1050                 }
1051
1052                 ::FLAC__MetadataType SimpleIterator::get_block_type() const
1053                 {
1054                         FLAC__ASSERT(is_valid());
1055                         return ::FLAC__metadata_simple_iterator_get_block_type(iterator_);
1056                 }
1057
1058                 Prototype *SimpleIterator::get_block()
1059                 {
1060                         FLAC__ASSERT(is_valid());
1061                         return local::construct_block(::FLAC__metadata_simple_iterator_get_block(iterator_));
1062                 }
1063
1064                 bool SimpleIterator::set_block(Prototype *block, bool use_padding)
1065                 {
1066                         FLAC__ASSERT(0 != block);
1067                         FLAC__ASSERT(is_valid());
1068                         return (bool)::FLAC__metadata_simple_iterator_set_block(iterator_, block->object_, use_padding);
1069                 }
1070
1071                 bool SimpleIterator::insert_block_after(Prototype *block, bool use_padding)
1072                 {
1073                         FLAC__ASSERT(0 != block);
1074                         FLAC__ASSERT(is_valid());
1075                         return (bool)::FLAC__metadata_simple_iterator_insert_block_after(iterator_, block->object_, use_padding);
1076                 }
1077
1078                 bool SimpleIterator::delete_block(bool use_padding)
1079                 {
1080                         FLAC__ASSERT(is_valid());
1081                         return (bool)::FLAC__metadata_simple_iterator_delete_block(iterator_, use_padding);
1082                 }
1083
1084
1085                 // ============================================================
1086                 //
1087                 //  Level 2
1088                 //
1089                 // ============================================================
1090
1091                 Chain::Chain():
1092                 chain_(::FLAC__metadata_chain_new())
1093                 { }
1094
1095                 Chain::~Chain()
1096                 {
1097                         clear();
1098                 }
1099
1100                 void Chain::clear()
1101                 {
1102                         if(0 != chain_)
1103                                 FLAC__metadata_chain_delete(chain_);
1104                         chain_ = 0;
1105                 }
1106
1107                 bool Chain::is_valid() const
1108                 {
1109                         return 0 != chain_;
1110                 }
1111
1112                 Chain::Status Chain::status()
1113                 {
1114                         FLAC__ASSERT(is_valid());
1115                         return Status(::FLAC__metadata_chain_status(chain_));
1116                 }
1117
1118                 bool Chain::read(const char *filename)
1119                 {
1120                         FLAC__ASSERT(0 != filename);
1121                         FLAC__ASSERT(is_valid());
1122                         return (bool)::FLAC__metadata_chain_read(chain_, filename);
1123                 }
1124
1125                 bool Chain::write(bool use_padding, bool preserve_file_stats)
1126                 {
1127                         FLAC__ASSERT(is_valid());
1128                         return (bool)::FLAC__metadata_chain_write(chain_, use_padding, preserve_file_stats);
1129                 }
1130
1131                 void Chain::merge_padding()
1132                 {
1133                         FLAC__ASSERT(is_valid());
1134                         ::FLAC__metadata_chain_merge_padding(chain_);
1135                 }
1136
1137                 void Chain::sort_padding()
1138                 {
1139                         FLAC__ASSERT(is_valid());
1140                         ::FLAC__metadata_chain_sort_padding(chain_);
1141                 }
1142
1143
1144                 Iterator::Iterator():
1145                 iterator_(::FLAC__metadata_iterator_new())
1146                 { }
1147
1148                 Iterator::~Iterator()
1149                 {
1150                         clear();
1151                 }
1152
1153                 void Iterator::clear()
1154                 {
1155                         if(0 != iterator_)
1156                                 FLAC__metadata_iterator_delete(iterator_);
1157                         iterator_ = 0;
1158                 }
1159
1160                 bool Iterator::is_valid() const
1161                 {
1162                         return 0 != iterator_;
1163                 }
1164
1165                 void Iterator::init(Chain &chain)
1166                 {
1167                         FLAC__ASSERT(is_valid());
1168                         FLAC__ASSERT(chain.is_valid());
1169                         ::FLAC__metadata_iterator_init(iterator_, chain.chain_);
1170                 }
1171
1172                 bool Iterator::next()
1173                 {
1174                         FLAC__ASSERT(is_valid());
1175                         return (bool)::FLAC__metadata_iterator_next(iterator_);
1176                 }
1177
1178                 bool Iterator::prev()
1179                 {
1180                         FLAC__ASSERT(is_valid());
1181                         return (bool)::FLAC__metadata_iterator_prev(iterator_);
1182                 }
1183
1184                 ::FLAC__MetadataType Iterator::get_block_type() const
1185                 {
1186                         FLAC__ASSERT(is_valid());
1187                         return ::FLAC__metadata_iterator_get_block_type(iterator_);
1188                 }
1189
1190                 Prototype *Iterator::get_block()
1191                 {
1192                         FLAC__ASSERT(is_valid());
1193                         Prototype *block = local::construct_block(::FLAC__metadata_iterator_get_block(iterator_));
1194                         if(0 != block)
1195                                 block->set_reference(true);
1196                         return block;
1197                 }
1198
1199                 bool Iterator::set_block(Prototype *block)
1200                 {
1201                         FLAC__ASSERT(0 != block);
1202                         FLAC__ASSERT(is_valid());
1203                         bool ret = (bool)::FLAC__metadata_iterator_set_block(iterator_, block->object_);
1204                         if(ret) {
1205                                 block->set_reference(true);
1206                                 delete block;
1207                         }
1208                         return ret;
1209                 }
1210
1211                 bool Iterator::delete_block(bool replace_with_padding)
1212                 {
1213                         FLAC__ASSERT(is_valid());
1214                         return (bool)::FLAC__metadata_iterator_delete_block(iterator_, replace_with_padding);
1215                 }
1216
1217                 bool Iterator::insert_block_before(Prototype *block)
1218                 {
1219                         FLAC__ASSERT(0 != block);
1220                         FLAC__ASSERT(is_valid());
1221                         bool ret = (bool)::FLAC__metadata_iterator_insert_block_before(iterator_, block->object_);
1222                         if(ret) {
1223                                 block->set_reference(true);
1224                                 delete block;
1225                         }
1226                         return ret;
1227                 }
1228
1229                 bool Iterator::insert_block_after(Prototype *block)
1230                 {
1231                         FLAC__ASSERT(0 != block);
1232                         FLAC__ASSERT(is_valid());
1233                         bool ret = (bool)::FLAC__metadata_iterator_insert_block_after(iterator_, block->object_);
1234                         if(ret) {
1235                                 block->set_reference(true);
1236                                 delete block;
1237                         }
1238                         return ret;
1239                 }
1240
1241         };
1242 };