← Back to branch summary

~njh-aelius/maxosx/musicbrainz-tags

« back to all changes in this revision

Viewing changes to Frameworks/taglib/taglib/taglib/mpeg/mpegfile.cpp

  • Committer: stephen_booth
  • Date: 2008-04-30 02:09:12 UTC
  • Revision ID: svn-v4:6b6cea13-1402-0410-9567-a7afb52bf336:trunk:1372
Update to latest taglib SVN

Show diffs side-by-side

added added

removed removed

Lines of Context:
Frameworks/taglib/taglib/taglib/mpeg/mpegfile.cpp
 
1
/***************************************************************************
 
2
    copyright            : (C) 2002 - 2008 by Scott Wheeler
 
3
    email                : wheeler@kde.org
 
4
 ***************************************************************************/
 
5
 
 
6
/***************************************************************************
 
7
 *   This library is free software; you can redistribute it and/or modify  *
 
8
 *   it under the terms of the GNU Lesser General Public License version   *
 
9
 *   2.1 as published by the Free Software Foundation.                     *
 
10
 *                                                                         *
 
11
 *   This library is distributed in the hope that it will be useful, but   *
 
12
 *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
 
13
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 
14
 *   Lesser General Public License for more details.                       *
 
15
 *                                                                         *
 
16
 *   You should have received a copy of the GNU Lesser General Public      *
 
17
 *   License along with this library; if not, write to the Free Software   *
 
18
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  *
 
19
 *   USA                                                                   *
 
20
 *                                                                         *
 
21
 *   Alternatively, this file is available under the Mozilla Public        *
 
22
 *   License Version 1.1.  You may obtain a copy of the License at         *
 
23
 *   http://www.mozilla.org/MPL/                                           *
 
24
 ***************************************************************************/
 
25
 
 
26
#include <tagunion.h>
 
27
#include <id3v2tag.h>
 
28
#include <id3v2header.h>
 
29
#include <id3v1tag.h>
 
30
#include <apefooter.h>
 
31
#include <apetag.h>
 
32
#include <tdebug.h>
 
33
 
 
34
#include <bitset>
 
35
 
 
36
#include "mpegfile.h"
 
37
#include "mpegheader.h"
 
38
 
 
39
using namespace TagLib;
 
40
 
 
41
namespace
 
42
{
 
43
  enum { ID3v2Index = 0, APEIndex = 1, ID3v1Index = 2 };
 
44
}
 
45
 
 
46
class MPEG::File::FilePrivate
 
47
{
 
48
public:
 
49
  FilePrivate(ID3v2::FrameFactory *frameFactory = ID3v2::FrameFactory::instance()) :
 
50
    ID3v2FrameFactory(frameFactory),
 
51
    ID3v2Location(-1),
 
52
    ID3v2OriginalSize(0),
 
53
    APELocation(-1),
 
54
    APEFooterLocation(-1),
 
55
    APEOriginalSize(0),
 
56
    ID3v1Location(-1),
 
57
    hasID3v2(false),
 
58
    hasID3v1(false),
 
59
    hasAPE(false),
 
60
    properties(0)
 
61
  {
 
62
 
 
63
  }
 
64
 
 
65
  ~FilePrivate()
 
66
  {
 
67
    delete properties;
 
68
  }
 
69
 
 
70
  const ID3v2::FrameFactory *ID3v2FrameFactory;
 
71
 
 
72
  long ID3v2Location;
 
73
  uint ID3v2OriginalSize;
 
74
 
 
75
  long APELocation;
 
76
  long APEFooterLocation;
 
77
  uint APEOriginalSize;
 
78
 
 
79
  long ID3v1Location;
 
80
 
 
81
  TagUnion tag;
 
82
 
 
83
  // These indicate whether the file *on disk* has these tags, not if
 
84
  // this data structure does.  This is used in computing offsets.
 
85
 
 
86
  bool hasID3v2;
 
87
  bool hasID3v1;
 
88
  bool hasAPE;
 
89
 
 
90
  Properties *properties;
 
91
};
 
92
 
 
93
////////////////////////////////////////////////////////////////////////////////
 
94
// public members
 
95
////////////////////////////////////////////////////////////////////////////////
 
96
 
 
97
MPEG::File::File(FileName file, bool readProperties,
 
98
                 Properties::ReadStyle propertiesStyle) : TagLib::File(file)
 
99
{
 
100
  d = new FilePrivate;
 
101
 
 
102
  if(isOpen())
 
103
    read(readProperties, propertiesStyle);
 
104
}
 
105
 
 
106
MPEG::File::File(FileName file, ID3v2::FrameFactory *frameFactory,
 
107
                 bool readProperties, Properties::ReadStyle propertiesStyle) :
 
108
  TagLib::File(file)
 
109
{
 
110
  d = new FilePrivate(frameFactory);
 
111
 
 
112
  if(isOpen())
 
113
    read(readProperties, propertiesStyle);
 
114
}
 
115
 
 
116
MPEG::File::~File()
 
117
{
 
118
  delete d;
 
119
}
 
120
 
 
121
TagLib::Tag *MPEG::File::tag() const
 
122
{
 
123
  return &d->tag;
 
124
}
 
125
 
 
126
MPEG::Properties *MPEG::File::audioProperties() const
 
127
{
 
128
  return d->properties;
 
129
}
 
130
 
 
131
bool MPEG::File::save()
 
132
{
 
133
  return save(AllTags);
 
134
}
 
135
 
 
136
bool MPEG::File::save(int tags)
 
137
{
 
138
  return save(tags, true);
 
139
}
 
140
 
 
141
bool MPEG::File::save(int tags, bool stripOthers)
 
142
{
 
143
  if(tags == NoTags && stripOthers)
 
144
    return strip(AllTags);
 
145
 
 
146
  if(!ID3v2Tag() && !ID3v1Tag() && !APETag()) {
 
147
 
 
148
    if((d->hasID3v1 || d->hasID3v2 || d->hasAPE) && stripOthers)
 
149
      return strip(AllTags);
 
150
 
 
151
    return true;
 
152
  }
 
153
 
 
154
  if(readOnly()) {
 
155
    debug("MPEG::File::save() -- File is read only.");
 
156
    return false;
 
157
  }
 
158
 
 
159
  // Create the tags if we've been asked to.  Copy the values from the tag that
 
160
  // does exist into the new tag.
 
161
 
 
162
  if((tags & ID3v2) && ID3v1Tag())
 
163
    Tag::duplicate(ID3v1Tag(), ID3v2Tag(true), false);
 
164
 
 
165
  if((tags & ID3v1) && d->tag[ID3v2Index])
 
166
    Tag::duplicate(ID3v2Tag(), ID3v1Tag(true), false);
 
167
 
 
168
  bool success = true;
 
169
 
 
170
  if(ID3v2 & tags) {
 
171
 
 
172
    if(ID3v2Tag() && !ID3v2Tag()->isEmpty()) {
 
173
 
 
174
      if(!d->hasID3v2)
 
175
        d->ID3v2Location = 0;
 
176
 
 
177
      insert(ID3v2Tag()->render(), d->ID3v2Location, d->ID3v2OriginalSize);
 
178
 
 
179
      d->hasID3v2 = true;
 
180
 
 
181
      // v1 tag location has changed, update if it exists
 
182
 
 
183
      if(ID3v1Tag())
 
184
        d->ID3v1Location = findID3v1();
 
185
 
 
186
      // APE tag location has changed, update if it exists
 
187
 
 
188
      if(APETag())
 
189
        findAPE();
 
190
    }
 
191
    else if(stripOthers)
 
192
      success = strip(ID3v2, false) && success;
 
193
  }
 
194
  else if(d->hasID3v2 && stripOthers)
 
195
    success = strip(ID3v2) && success;
 
196
 
 
197
  if(ID3v1 & tags) {
 
198
    if(ID3v1Tag() && !ID3v1Tag()->isEmpty()) {
 
199
      int offset = d->hasID3v1 ? -128 : 0;
 
200
      seek(offset, End);
 
201
      writeBlock(ID3v1Tag()->render());
 
202
      d->hasID3v1 = true;
 
203
      d->ID3v1Location = findID3v1();
 
204
    }
 
205
    else if(stripOthers)
 
206
      success = strip(ID3v1) && success;
 
207
  }
 
208
  else if(d->hasID3v1 && stripOthers)
 
209
    success = strip(ID3v1, false) && success;
 
210
 
 
211
  // Dont save an APE-tag unless one has been created
 
212
 
 
213
  if((APE & tags) && APETag()) {
 
214
    if(d->hasAPE)
 
215
      insert(APETag()->render(), d->APELocation, d->APEOriginalSize);
 
216
    else {
 
217
      if(d->hasID3v1) {
 
218
        insert(APETag()->render(), d->ID3v1Location, 0);
 
219
        d->APEOriginalSize = APETag()->footer()->completeTagSize();
 
220
        d->hasAPE = true;
 
221
        d->APELocation = d->ID3v1Location;
 
222
        d->ID3v1Location += d->APEOriginalSize;
 
223
      }
 
224
      else {
 
225
        seek(0, End);
 
226
        d->APELocation = tell();
 
227
        d->APEFooterLocation = d->APELocation
 
228
          + d->tag.access<APE::Tag>(APEIndex, false)->footer()->completeTagSize()
 
229
          - APE::Footer::size();
 
230
        writeBlock(APETag()->render());
 
231
        d->APEOriginalSize = APETag()->footer()->completeTagSize();
 
232
        d->hasAPE = true;
 
233
      }
 
234
    }
 
235
  }
 
236
  else if(d->hasAPE && stripOthers)
 
237
    success = strip(APE, false) && success;
 
238
 
 
239
  return success;
 
240
}
 
241
 
 
242
ID3v2::Tag *MPEG::File::ID3v2Tag(bool create)
 
243
{
 
244
  return d->tag.access<ID3v2::Tag>(ID3v2Index, create);
 
245
}
 
246
 
 
247
ID3v1::Tag *MPEG::File::ID3v1Tag(bool create)
 
248
{
 
249
  return d->tag.access<ID3v1::Tag>(ID3v1Index, create);
 
250
}
 
251
 
 
252
APE::Tag *MPEG::File::APETag(bool create)
 
253
{
 
254
  return d->tag.access<APE::Tag>(APEIndex, create);
 
255
}
 
256
 
 
257
bool MPEG::File::strip(int tags)
 
258
{
 
259
  return strip(tags, true);
 
260
}
 
261
 
 
262
bool MPEG::File::strip(int tags, bool freeMemory)
 
263
{
 
264
  if(readOnly()) {
 
265
    debug("MPEG::File::strip() - Cannot strip tags from a read only file.");
 
266
    return false;
 
267
  }
 
268
 
 
269
  if((tags & ID3v2) && d->hasID3v2) {
 
270
    removeBlock(d->ID3v2Location, d->ID3v2OriginalSize);
 
271
    d->ID3v2Location = -1;
 
272
    d->ID3v2OriginalSize = 0;
 
273
    d->hasID3v2 = false;
 
274
 
 
275
    if(freeMemory)
 
276
      d->tag.set(ID3v2Index, 0);
 
277
 
 
278
    // v1 tag location has changed, update if it exists
 
279
 
 
280
    if(ID3v1Tag())
 
281
      d->ID3v1Location = findID3v1();
 
282
 
 
283
    // APE tag location has changed, update if it exists
 
284
 
 
285
   if(APETag())
 
286
      findAPE();
 
287
  }
 
288
 
 
289
  if((tags & ID3v1) && d->hasID3v1) {
 
290
    truncate(d->ID3v1Location);
 
291
    d->ID3v1Location = -1;
 
292
    d->hasID3v1 = false;
 
293
 
 
294
    if(freeMemory)
 
295
      d->tag.set(ID3v1Index, 0);
 
296
  }
 
297
 
 
298
  if((tags & APE) && d->hasAPE) {
 
299
    removeBlock(d->APELocation, d->APEOriginalSize);
 
300
    d->APELocation = -1;
 
301
    d->APEFooterLocation = -1;
 
302
    d->hasAPE = false;
 
303
    if(d->hasID3v1) {
 
304
      if(d->ID3v1Location > d->APELocation)
 
305
        d->ID3v1Location -= d->APEOriginalSize;
 
306
    }
 
307
 
 
308
    if(freeMemory)
 
309
      d->tag.set(APEIndex, 0);
 
310
  }
 
311
 
 
312
  return true;
 
313
}
 
314
 
 
315
void MPEG::File::setID3v2FrameFactory(const ID3v2::FrameFactory *factory)
 
316
{
 
317
  d->ID3v2FrameFactory = factory;
 
318
}
 
319
 
 
320
long MPEG::File::nextFrameOffset(long position)
 
321
{
 
322
  bool foundLastSyncPattern = false;
 
323
 
 
324
  ByteVector buffer;
 
325
 
 
326
  while(true) {
 
327
    seek(position);
 
328
    buffer = readBlock(bufferSize());
 
329
 
 
330
    if(buffer.size() <= 0)
 
331
      return -1;
 
332
 
 
333
    if(foundLastSyncPattern && secondSynchByte(buffer[0]))
 
334
      return position - 1;
 
335
 
 
336
    for(uint i = 0; i < buffer.size() - 1; i++) {
 
337
      if(uchar(buffer[i]) == 0xff && secondSynchByte(buffer[i + 1]))
 
338
        return position + i;
 
339
    }
 
340
 
 
341
    foundLastSyncPattern = uchar(buffer[buffer.size() - 1]) == 0xff;
 
342
    position += buffer.size();
 
343
  }
 
344
}
 
345
 
 
346
long MPEG::File::previousFrameOffset(long position)
 
347
{
 
348
  bool foundFirstSyncPattern = false;
 
349
  ByteVector buffer;
 
350
 
 
351
  while (position > 0) {
 
352
    long size = ulong(position) < bufferSize() ? position : bufferSize();
 
353
    position -= size;
 
354
 
 
355
    seek(position);
 
356
    buffer = readBlock(size);
 
357
 
 
358
    if(buffer.size() <= 0)
 
359
      break;
 
360
 
 
361
    if(foundFirstSyncPattern && uchar(buffer[buffer.size() - 1]) == 0xff)
 
362
      return position + buffer.size() - 1;
 
363
 
 
364
    for(int i = buffer.size() - 2; i >= 0; i--) {
 
365
      if(uchar(buffer[i]) == 0xff && secondSynchByte(buffer[i + 1]))
 
366
        return position + i;
 
367
    }
 
368
 
 
369
    foundFirstSyncPattern = secondSynchByte(buffer[0]);
 
370
  }
 
371
  return -1;
 
372
}
 
373
 
 
374
long MPEG::File::firstFrameOffset()
 
375
{
 
376
  long position = 0;
 
377
 
 
378
  if(ID3v2Tag())
 
379
    position = d->ID3v2Location + ID3v2Tag()->header()->completeTagSize();
 
380
 
 
381
  return nextFrameOffset(position);
 
382
}
 
383
 
 
384
long MPEG::File::lastFrameOffset()
 
385
{
 
386
  return previousFrameOffset(ID3v1Tag() ? d->ID3v1Location - 1 : length());
 
387
}
 
388
 
 
389
////////////////////////////////////////////////////////////////////////////////
 
390
// private members
 
391
////////////////////////////////////////////////////////////////////////////////
 
392
 
 
393
void MPEG::File::read(bool readProperties, Properties::ReadStyle propertiesStyle)
 
394
{
 
395
  // Look for an ID3v2 tag
 
396
 
 
397
  d->ID3v2Location = findID3v2();
 
398
 
 
399
  if(d->ID3v2Location >= 0) {
 
400
 
 
401
    d->tag.set(ID3v2Index, new ID3v2::Tag(this, d->ID3v2Location, d->ID3v2FrameFactory));
 
402
 
 
403
    d->ID3v2OriginalSize = ID3v2Tag()->header()->completeTagSize();
 
404
 
 
405
    if(ID3v2Tag()->header()->tagSize() <= 0)
 
406
      d->tag.set(ID3v2Index, 0);
 
407
    else
 
408
      d->hasID3v2 = true;
 
409
  }
 
410
 
 
411
  // Look for an ID3v1 tag
 
412
 
 
413
  d->ID3v1Location = findID3v1();
 
414
 
 
415
  if(d->ID3v1Location >= 0) {
 
416
    d->tag.set(ID3v1Index, new ID3v1::Tag(this, d->ID3v1Location));
 
417
    d->hasID3v1 = true;
 
418
  }
 
419
 
 
420
  // Look for an APE tag
 
421
 
 
422
  findAPE();
 
423
 
 
424
  if(d->APELocation >= 0) {
 
425
 
 
426
    d->tag.set(APEIndex, new APE::Tag(this, d->APEFooterLocation));
 
427
    d->APEOriginalSize = APETag()->footer()->completeTagSize();
 
428
    d->hasAPE = true;
 
429
  }
 
430
 
 
431
  if(readProperties)
 
432
    d->properties = new Properties(this, propertiesStyle);
 
433
 
 
434
  // Make sure that we have our default tag types available.
 
435
 
 
436
  ID3v2Tag(true);
 
437
  ID3v1Tag(true);
 
438
}
 
439
 
 
440
long MPEG::File::findID3v2()
 
441
{
 
442
  // This method is based on the contents of TagLib::File::find(), but because
 
443
  // of some subtlteies -- specifically the need to look for the bit pattern of
 
444
  // an MPEG sync, it has been modified for use here.
 
445
 
 
446
  if(isValid() && ID3v2::Header::fileIdentifier().size() <= bufferSize()) {
 
447
 
 
448
    // The position in the file that the current buffer starts at.
 
449
 
 
450
    long bufferOffset = 0;
 
451
    ByteVector buffer;
 
452
 
 
453
    // These variables are used to keep track of a partial match that happens at
 
454
    // the end of a buffer.
 
455
 
 
456
    int previousPartialMatch = -1;
 
457
    bool previousPartialSynchMatch = false;
 
458
 
 
459
    // Save the location of the current read pointer.  We will restore the
 
460
    // position using seek() before all returns.
 
461
 
 
462
    long originalPosition = tell();
 
463
 
 
464
    // Start the search at the beginning of the file.
 
465
 
 
466
    seek(0);
 
467
 
 
468
    // This loop is the crux of the find method.  There are three cases that we
 
469
    // want to account for:
 
470
    // (1) The previously searched buffer contained a partial match of the search
 
471
    // pattern and we want to see if the next one starts with the remainder of
 
472
    // that pattern.
 
473
    //
 
474
    // (2) The search pattern is wholly contained within the current buffer.
 
475
    //
 
476
    // (3) The current buffer ends with a partial match of the pattern.  We will
 
477
    // note this for use in the next itteration, where we will check for the rest
 
478
    // of the pattern.
 
479
 
 
480
    for(buffer = readBlock(bufferSize()); buffer.size() > 0; buffer = readBlock(bufferSize())) {
 
481
 
 
482
      // (1) previous partial match
 
483
 
 
484
      if(previousPartialSynchMatch && secondSynchByte(buffer[0]))
 
485
        return -1;
 
486
 
 
487
      if(previousPartialMatch >= 0 && int(bufferSize()) > previousPartialMatch) {
 
488
        const int patternOffset = (bufferSize() - previousPartialMatch);
 
489
        if(buffer.containsAt(ID3v2::Header::fileIdentifier(), 0, patternOffset)) {
 
490
          seek(originalPosition);
 
491
          return bufferOffset - bufferSize() + previousPartialMatch;
 
492
        }
 
493
      }
 
494
 
 
495
      // (2) pattern contained in current buffer
 
496
 
 
497
      long location = buffer.find(ID3v2::Header::fileIdentifier());
 
498
      if(location >= 0) {
 
499
        seek(originalPosition);
 
500
        return bufferOffset + location;
 
501
      }
 
502
 
 
503
      int firstSynchByte = buffer.find(char(uchar(255)));
 
504
 
 
505
      // Here we have to loop because there could be several of the first
 
506
      // (11111111) byte, and we want to check all such instances until we find
 
507
      // a full match (11111111 111) or hit the end of the buffer.
 
508
 
 
509
      while(firstSynchByte >= 0) {
 
510
 
 
511
        // if this *is not* at the end of the buffer
 
512
 
 
513
        if(firstSynchByte < int(buffer.size()) - 1) {
 
514
          if(secondSynchByte(buffer[firstSynchByte + 1])) {
 
515
            // We've found the frame synch pattern.
 
516
            seek(originalPosition);
 
517
            return -1;
 
518
          }
 
519
          else {
 
520
 
 
521
            // We found 11111111 at the end of the current buffer indicating a
 
522
            // partial match of the synch pattern.  The find() below should
 
523
            // return -1 and break out of the loop.
 
524
 
 
525
            previousPartialSynchMatch = true;
 
526
          }
 
527
        }
 
528
 
 
529
        // Check in the rest of the buffer.
 
530
 
 
531
        firstSynchByte = buffer.find(char(uchar(255)), firstSynchByte + 1);
 
532
      }
 
533
 
 
534
      // (3) partial match
 
535
 
 
536
      previousPartialMatch = buffer.endsWithPartialMatch(ID3v2::Header::fileIdentifier());
 
537
 
 
538
      bufferOffset += bufferSize();
 
539
    }
 
540
 
 
541
    // Since we hit the end of the file, reset the status before continuing.
 
542
 
 
543
    clear();
 
544
 
 
545
    seek(originalPosition);
 
546
  }
 
547
 
 
548
  return -1;
 
549
}
 
550
 
 
551
long MPEG::File::findID3v1()
 
552
{
 
553
  if(isValid()) {
 
554
    seek(-128, End);
 
555
    long p = tell();
 
556
 
 
557
    if(readBlock(3) == ID3v1::Tag::fileIdentifier())
 
558
      return p;
 
559
  }
 
560
  return -1;
 
561
}
 
562
 
 
563
void MPEG::File::findAPE()
 
564
{
 
565
  if(isValid()) {
 
566
    seek(d->hasID3v1 ? -160 : -32, End);
 
567
 
 
568
    long p = tell();
 
569
 
 
570
    if(readBlock(8) == APE::Tag::fileIdentifier()) {
 
571
      d->APEFooterLocation = p;
 
572
      seek(d->APEFooterLocation);
 
573
      APE::Footer footer(readBlock(APE::Footer::size()));
 
574
      d->APELocation = d->APEFooterLocation - footer.completeTagSize()
 
575
        + APE::Footer::size();
 
576
      return;
 
577
    }
 
578
  }
 
579
 
 
580
  d->APELocation = -1;
 
581
  d->APEFooterLocation = -1;
 
582
}
 
583
 
 
584
bool MPEG::File::secondSynchByte(char byte)
 
585
{
 
586
  if(uchar(byte) == 0xff)
 
587
    return false;
 
588
 
 
589
  std::bitset<8> b(byte);
 
590
 
 
591
  // check to see if the byte matches 111xxxxx
 
592
  return b.test(7) && b.test(6) && b.test(5);
 
593
}