src/libFLAC++/metadata.cpp

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