apps/mp3data.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 by Daniel Stenberg
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22 /*
  23  * Parts of this code has been stolen from the Ample project and was written
  24  * by David Härdeman. It has since been extended and enhanced pretty much by
  25  * all sorts of friendly Rockbox people.
  26  *
  27  * A nice reference for MPEG header info:
  28  * http://rockbox.haxx.se/docs/mpeghdr.html
  29  *
  30  */
  31
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <stdbool.h>
  36 #include <limits.h>
  37 #include "debug.h"
  38 #include "logf.h"
  39 #include "mp3data.h"
  40 #include "file.h"
  41 #include "buffer.h"
  42
  43 // #define DEBUG_VERBOSE
  44
  45 #define SYNC_MASK (0x7ffL << 21)
  46 #define VERSION_MASK (3L << 19)
  47 #define LAYER_MASK (3L << 17)
  48 #define PROTECTION_MASK (1L << 16)
  49 #define BITRATE_MASK (0xfL << 12)
  50 #define SAMPLERATE_MASK (3L << 10)
  51 #define PADDING_MASK (1L << 9)
  52 #define PRIVATE_MASK (1L << 8)
  53 #define CHANNELMODE_MASK (3L << 6)
  54 #define MODE_EXT_MASK (3L << 4)
  55 #define COPYRIGHT_MASK (1L << 3)
  56 #define ORIGINAL_MASK (1L << 2)
  57 #define EMPHASIS_MASK 3L
  58
  59 /* MPEG Version table, sorted by version index */
  60 static const signed char version_table[4] = {
  61     MPEG_VERSION2_5, -1, MPEG_VERSION2, MPEG_VERSION1
  62 };
  63
  64 /* Bitrate table for mpeg audio, indexed by row index and birate index */
  65 static const short bitrates[5][16] = {
  66     {0,32,64,96,128,160,192,224,256,288,320,352,384,416,448,0}, /* V1 L1 */
  67     {0,32,48,56, 64, 80, 96,112,128,160,192,224,256,320,384,0}, /* V1 L2 */
  68     {0,32,40,48, 56, 64, 80, 96,112,128,160,192,224,256,320,0}, /* V1 L3 */
  69     {0,32,48,56, 64, 80, 96,112,128,144,160,176,192,224,256,0}, /* V2 L1 */
  70     {0, 8,16,24, 32, 40, 48, 56, 64, 80, 96,112,128,144,160,0}  /* V2 L2+L3 */
  71 };
  72
  73 /* Bitrate pointer table, indexed by version and layer */
  74 static const short *bitrate_table[3][3] =
  75 {
  76     {bitrates[0], bitrates[1], bitrates[2]},
  77     {bitrates[3], bitrates[4], bitrates[4]},
  78     {bitrates[3], bitrates[4], bitrates[4]}
  79 };
  80
  81 /* Sampling frequency table, indexed by version and frequency index */
  82 static const unsigned short freq_table[3][3] =
  83 {
  84     {44100, 48000, 32000}, /* MPEG Version 1 */
  85     {22050, 24000, 16000}, /* MPEG version 2 */
  86     {11025, 12000,  8000}, /* MPEG version 2.5 */
  87 };
  88
  89 unsigned long bytes2int(unsigned long b0,
  90                      unsigned long b1,
  91                      unsigned long b2,
  92                      unsigned long b3)
  93 {
  94    return (((long)(b0 & 0xFF) << (3*8)) |
  95            ((long)(b1 & 0xFF) << (2*8)) |
  96            ((long)(b2 & 0xFF) << (1*8)) |
  97            ((long)(b3 & 0xFF) << (0*8)));
  98 }
  99
 100 /* check if 'head' is a valid mp3 frame header */
 101 static bool is_mp3frameheader(unsigned long head)
 102 {
 103     if ((head & SYNC_MASK) != (unsigned long)SYNC_MASK) /* bad sync? */
 104         return false;
 105     if ((head & VERSION_MASK) == (1L << 19)) /* bad version? */
 106         return false;
 107     if (!(head & LAYER_MASK)) /* no layer? */
 108         return false;
 109 #if CONFIG_CODEC != SWCODEC
 110     /* The MAS can't decode layer 1, so treat layer 1 data as invalid */
 111     if ((head & LAYER_MASK) == LAYER_MASK)
 112         return false;
 113 #endif
 114     if ((head & BITRATE_MASK) == BITRATE_MASK) /* bad bitrate? */
 115         return false;
 116     if (!(head & BITRATE_MASK)) /* no bitrate? */
 117         return false;
 118     if ((head & SAMPLERATE_MASK) == SAMPLERATE_MASK) /* bad sample rate? */
 119         return false;
 120
 121     return true;
 122 }
 123
 124 static bool mp3headerinfo(struct mp3info *info, unsigned long header)
 125 {
 126     int bitindex, freqindex;
 127
 128     /* MPEG Audio Version */
 129     if ((header & VERSION_MASK) >> 19 >= sizeof(version_table))
 130         return false;
 131
 132     info->version = version_table[(header & VERSION_MASK) >> 19];
 133     if (info->version < 0)
 134         return false;
 135
 136     /* Layer */
 137     info->layer = 3 - ((header & LAYER_MASK) >> 17);
 138     if (info->layer == 3)
 139         return false;
 140
 141     info->protection = (header & PROTECTION_MASK) ? true : false;
 142
 143     /* Bitrate */
 144     bitindex = (header & BITRATE_MASK) >> 12;
 145     info->bitrate = bitrate_table[info->version][info->layer][bitindex];
 146     if(info->bitrate == 0)
 147         return false;
 148
 149     /* Sampling frequency */
 150     freqindex = (header & SAMPLERATE_MASK) >> 10;
 151     if (freqindex == 3)
 152         return false;
 153     info->frequency = freq_table[info->version][freqindex];
 154
 155     info->padding = (header & PADDING_MASK) ? 1 : 0;
 156
 157     /* Calculate number of bytes, calculation depends on layer */
 158     if (info->layer == 0) {
 159         info->frame_samples = 384;
 160         info->frame_size = (12000 * info->bitrate / info->frequency
 161                             + info->padding) * 4;
 162     }
 163     else {
 164         if ((info->version > MPEG_VERSION1) && (info->layer == 2))
 165             info->frame_samples = 576;
 166         else
 167             info->frame_samples = 1152;
 168         info->frame_size = (1000/8) * info->frame_samples * info->bitrate
 169                            / info->frequency + info->padding;
 170     }
 171
 172     /* Frametime fraction denominator */
 173     if (freqindex != 0) {      /* 48/32/24/16/12/8 kHz */
 174         info->ft_den = 1;      /* integer number of milliseconds */
 175     }
 176     else {                     /* 44.1/22.05/11.025 kHz */
 177         if (info->layer == 0)     /* layer 1 */
 178             info->ft_den = 147;
 179         else                      /* layer 2+3 */
 180             info->ft_den = 49;
 181     }
 182     /* Frametime fraction numerator */
 183     info->ft_num = 1000 * info->ft_den * info->frame_samples / info->frequency;
 184
 185     info->channel_mode = (header & CHANNELMODE_MASK) >> 6;
 186     info->mode_extension = (header & MODE_EXT_MASK) >> 4;
 187     info->emphasis = header & EMPHASIS_MASK;
 188
 189 #ifdef DEBUG_VERBOSE
 190     DEBUGF( "Header: %08lx, Ver %d, lay %d, bitr %d, freq %ld, "
 191             "chmode %d, mode_ext %d, emph %d, bytes: %d time: %d/%d\n",
 192             header, info->version, info->layer+1, info->bitrate,
 193             info->frequency, info->channel_mode, info->mode_extension,
 194             info->emphasis, info->frame_size, info->ft_num, info->ft_den);
 195 #endif
 196     return true;
 197 }
 198
 199 static unsigned long __find_next_frame(int fd, long *offset, long max_offset,
 200                                        unsigned long last_header,
 201                                        int(*getfunc)(int fd, unsigned char *c))
 202 {
 203     unsigned long header=0;
 204     unsigned char tmp;
 205     int i;
 206
 207     long pos = 0;
 208
 209     /* We remember the last header we found, to use as a template to see if
 210        the header we find has the same frequency, layer etc */
 211     last_header &= 0xffff0c00;
 212
 213     /* Fill up header with first 24 bits */
 214     for(i = 0; i < 3; i++) {
 215         header <<= 8;
 216         if(!getfunc(fd, &tmp))
 217             return 0;
 218         header |= tmp;
 219         pos++;
 220     }
 221
 222     do {
 223         header <<= 8;
 224         if(!getfunc(fd, &tmp))
 225             return 0;
 226         header |= tmp;
 227         pos++;
 228         if(max_offset > 0 && pos > max_offset)
 229             return 0;
 230     } while(!is_mp3frameheader(header) ||
 231             (last_header?((header & 0xffff0c00) != last_header):false));
 232
 233     *offset = pos - 4;
 234
 235 #if defined(DEBUG)
 236     if(*offset)
 237         DEBUGF("Warning: skipping %ld bytes of garbage\n", *offset);
 238 #endif
 239
 240     return header;
 241 }
 242
 243 static int fileread(int fd, unsigned char *c)
 244 {
 245     return read(fd, c, 1);
 246 }
 247
 248 unsigned long find_next_frame(int fd, long *offset, long max_offset, unsigned long last_header)
 249 {
 250     return __find_next_frame(fd, offset, max_offset, last_header, fileread);
 251 }
 252
 253 #ifndef __PCTOOL__
 254 static int fnf_read_index;
 255 static int fnf_buf_len;
 256
 257 static int buf_getbyte(int fd, unsigned char *c)
 258 {
 259     if(fnf_read_index < fnf_buf_len)
 260     {
 261         *c = audiobuf[fnf_read_index++];
 262         return 1;
 263     }
 264     else
 265     {
 266         fnf_buf_len = read(fd, audiobuf, audiobufend - audiobuf);
 267         if(fnf_buf_len < 0)
 268             return -1;
 269
 270         fnf_read_index = 0;
 271
 272         if(fnf_buf_len > 0)
 273         {
 274             *c = audiobuf[fnf_read_index++];
 275             return 1;
 276         }
 277         else
 278             return 0;
 279     }
 280     return 0;
 281 }
 282
 283 static int buf_seek(int fd, int len)
 284 {
 285     fnf_read_index += len;
 286     if(fnf_read_index > fnf_buf_len)
 287     {
 288         len = fnf_read_index - fnf_buf_len;
 289
 290         fnf_buf_len = read(fd, audiobuf, audiobufend - audiobuf);
 291         if(fnf_buf_len < 0)
 292             return -1;
 293
 294         fnf_read_index = 0;
 295         fnf_read_index += len;
 296     }
 297
 298     if(fnf_read_index > fnf_buf_len)
 299     {
 300         return -1;
 301     }
 302     else
 303         return 0;
 304 }
 305
 306 static void buf_init(void)
 307 {
 308     fnf_buf_len = 0;
 309     fnf_read_index = 0;
 310 }
 311
 312 static unsigned long buf_find_next_frame(int fd, long *offset, long max_offset,
 313                                          unsigned long last_header)
 314 {
 315     return __find_next_frame(fd, offset, max_offset, last_header, buf_getbyte);
 316 }
 317
 318 static int audiobuflen;
 319 static int mem_pos;
 320 static int mem_cnt;
 321 static int mem_maxlen;
 322
 323 static int mem_getbyte(int dummy, unsigned char *c)
 324 {
 325     dummy = dummy;
 326
 327     *c = audiobuf[mem_pos++];
 328     if(mem_pos >= audiobuflen)
 329         mem_pos = 0;
 330
 331     if(mem_cnt++ >= mem_maxlen)
 332         return 0;
 333     else
 334         return 1;
 335 }
 336
 337 unsigned long mem_find_next_frame(int startpos, long *offset, long max_offset,
 338                                   unsigned long last_header)
 339 {
 340     audiobuflen = audiobufend - audiobuf;
 341     mem_pos = startpos;
 342     mem_cnt = 0;
 343     mem_maxlen = max_offset;
 344
 345     return __find_next_frame(0, offset, max_offset, last_header, mem_getbyte);
 346 }
 347 #endif
 348
 349 int get_mp3file_info(int fd, struct mp3info *info)
 350 {
 351     unsigned char frame[1800];
 352     unsigned char *vbrheader;
 353     unsigned long header;
 354     long bytecount;
 355     int num_offsets;
 356     int frames_per_entry;
 357     int i;
 358     long offset;
 359     int j;
 360     long tmp;
 361
 362     header = find_next_frame(fd, &bytecount, 0x20000, 0);
 363     /* Quit if we haven't found a valid header within 128K */
 364     if(header == 0)
 365         return -1;
 366
 367     memset(info, 0, sizeof(struct mp3info));
 368 #if CONFIG_CODEC==SWCODEC
 369     /* These two are needed for proper LAME gapless MP3 playback */
 370     info->enc_delay = -1;
 371     info->enc_padding = -1;
 372 #endif
 373     if(!mp3headerinfo(info, header))
 374         return -2;
 375
 376     /* OK, we have found a frame. Let's see if it has a Xing header */
 377     if (info->frame_size-4 >= (int)sizeof(frame))
 378     {
 379 #if defined(DEBUG)
 380         DEBUGF("Error: Invalid id3 header, frame_size: %d\n", info->frame_size);
 381 #endif
 382         return -8;
 383     }
 384
 385     if(read(fd, frame, info->frame_size-4) < 0)
 386         return -3;
 387
 388     /* calculate position of VBR header */
 389     if ( info->version == MPEG_VERSION1 ) {
 390         if (info->channel_mode == 3) /* mono */
 391             vbrheader = frame + 17;
 392         else
 393             vbrheader = frame + 32;
 394     }
 395     else {
 396         if (info->channel_mode == 3) /* mono */
 397             vbrheader = frame + 9;
 398         else
 399             vbrheader = frame + 17;
 400     }
 401
 402     if (!memcmp(vbrheader, "Xing", 4)
 403         || !memcmp(vbrheader, "Info", 4))
 404     {
 405         int i = 8; /* Where to start parsing info */
 406
 407         /* DEBUGF("Xing/Info header\n"); */
 408
 409         /* Remember where in the file the Xing header is */
 410         info->vbr_header_pos = lseek(fd, 0, SEEK_CUR) - info->frame_size;
 411
 412         /* We want to skip the Xing frame when playing the stream */
 413         bytecount += info->frame_size;
 414
 415         /* Now get the next frame to find out the real info about
 416            the mp3 stream */
 417         header = find_next_frame(fd, &tmp, 0x20000, 0);
 418         if(header == 0)
 419             return -4;
 420
 421         if(!mp3headerinfo(info, header))
 422             return -5;
 423
 424         /* Is it a VBR file? */
 425         info->is_vbr = info->is_xing_vbr = !memcmp(vbrheader, "Xing", 4);
 426
 427         if (vbrheader[7] & VBR_FRAMES_FLAG) /* Is the frame count there? */
 428         {
 429             info->frame_count = bytes2int(vbrheader[i], vbrheader[i+1],
 430                                           vbrheader[i+2], vbrheader[i+3]);
 431             if (info->frame_count <= ULONG_MAX / info->ft_num)
 432                 info->file_time = info->frame_count * info->ft_num / info->ft_den;
 433             else
 434                 info->file_time = info->frame_count / info->ft_den * info->ft_num;
 435             i += 4;
 436         }
 437
 438         if (vbrheader[7] & VBR_BYTES_FLAG) /* Is byte count there? */
 439         {
 440             info->byte_count = bytes2int(vbrheader[i], vbrheader[i+1],
 441                                          vbrheader[i+2], vbrheader[i+3]);
 442             i += 4;
 443         }
 444
 445         if (info->file_time && info->byte_count)
 446         {
 447             if (info->byte_count <= (ULONG_MAX/8))
 448                 info->bitrate = info->byte_count * 8 / info->file_time;
 449             else
 450                 info->bitrate = info->byte_count / (info->file_time >> 3);
 451         }
 452         else
 453             info->bitrate = 0;
 454
 455         if (vbrheader[7] & VBR_TOC_FLAG) /* Is table-of-contents there? */
 456         {
 457             info->has_toc = true;
 458             memcpy( info->toc, vbrheader+i, 100 );
 459             i += 100;
 460         }
 461         if (vbrheader[7] & VBR_QUALITY_FLAG)
 462         {
 463             /* We don't care about this, but need to skip it */
 464             i += 4;
 465         }
 466 #if CONFIG_CODEC==SWCODEC
 467         i += 21;
 468         info->enc_delay = (vbrheader[i] << 4) | (vbrheader[i + 1] >> 4);
 469         info->enc_padding = ((vbrheader[i + 1] & 0x0f) << 8) | vbrheader[i + 2];
 470         /* TODO: This sanity checking is rather silly, seeing as how the LAME
 471            header contains a CRC field that can be used to verify integrity. */
 472         if (!(info->enc_delay >= 0 && info->enc_delay <= 2880 &&
 473             info->enc_padding >= 0 && info->enc_padding <= 2*1152))
 474         {
 475            /* Invalid data */
 476            info->enc_delay = -1;
 477            info->enc_padding = -1;
 478         }
 479 #endif
 480     }
 481
 482     if (!memcmp(vbrheader, "VBRI", 4))
 483     {
 484         DEBUGF("VBRI header\n");
 485
 486         /* We want to skip the VBRI frame when playing the stream */
 487         bytecount += info->frame_size;
 488
 489         /* Now get the next frame to find out the real info about
 490            the mp3 stream */
 491         header = find_next_frame(fd, &tmp, 0x20000, 0);
 492         if(header == 0)
 493             return -6;
 494
 495         bytecount += tmp;
 496
 497         if(!mp3headerinfo(info, header))
 498             return -7;
 499
 500         DEBUGF("%04x: %04x %04x ", 0, (short)(header >> 16),
 501                (short)(header & 0xffff));
 502         for(i = 4;i < (int)sizeof(frame)-4;i+=2) {
 503             if(i % 16 == 0) {
 504                 DEBUGF("\n%04x: ", i-4);
 505             }
 506             DEBUGF("%04x ", (frame[i-4] << 8) | frame[i-4+1]);
 507         }
 508
 509         DEBUGF("\n");
 510
 511         /* Yes, it is a FhG VBR file */
 512         info->is_vbr = true;
 513         info->is_vbri_vbr = true;
 514         info->has_toc = false; /* We don't parse the TOC (yet) */
 515
 516         info->byte_count = bytes2int(vbrheader[10], vbrheader[11],
 517                                      vbrheader[12], vbrheader[13]);
 518         info->frame_count = bytes2int(vbrheader[14], vbrheader[15],
 519                                       vbrheader[16], vbrheader[17]);
 520         if (info->frame_count <= ULONG_MAX / info->ft_num)
 521             info->file_time = info->frame_count * info->ft_num / info->ft_den;
 522         else
 523             info->file_time = info->frame_count / info->ft_den * info->ft_num;
 524
 525         if (info->byte_count <= (ULONG_MAX/8))
 526             info->bitrate = info->byte_count * 8 / info->file_time;
 527         else
 528             info->bitrate = info->byte_count / (info->file_time >> 3);
 529
 530         /* We don't parse the TOC, since we don't yet know how to (FIXME) */
 531         num_offsets = bytes2int(0, 0, vbrheader[18], vbrheader[19]);
 532         frames_per_entry = bytes2int(0, 0, vbrheader[24], vbrheader[25]);
 533         DEBUGF("Frame size (%dkpbs): %d bytes (0x%x)\n",
 534                info->bitrate, info->frame_size, info->frame_size);
 535         DEBUGF("Frame count: %lx\n", info->frame_count);
 536         DEBUGF("Byte count: %lx\n", info->byte_count);
 537         DEBUGF("Offsets: %d\n", num_offsets);
 538         DEBUGF("Frames/entry: %d\n", frames_per_entry);
 539
 540         offset = 0;
 541
 542         for(i = 0;i < num_offsets;i++)
 543         {
 544            j = bytes2int(0, 0, vbrheader[26+i*2], vbrheader[27+i*2]);
 545            offset += j;
 546            DEBUGF("%03d: %lx (%x)\n", i, offset - bytecount, j);
 547         }
 548     }
 549
 550     return bytecount;
 551 }
 552
 553 #ifndef __PCTOOL__
 554 static void long2bytes(unsigned char *buf, long val)
 555 {
 556     buf[0] = (val >> 24) & 0xff;
 557     buf[1] = (val >> 16) & 0xff;
 558     buf[2] = (val >> 8) & 0xff;
 559     buf[3] = val & 0xff;
 560 }
 561
 562 int count_mp3_frames(int fd, int startpos, int filesize,
 563                      void (*progressfunc)(int))
 564 {
 565     unsigned long header = 0;
 566     struct mp3info info;
 567     int num_frames;
 568     long bytes;
 569     int cnt;
 570     long progress_chunk = filesize / 50; /* Max is 50%, in 1% increments */
 571     int progress_cnt = 0;
 572     bool is_vbr = false;
 573     int last_bitrate = 0;
 574     int header_template = 0;
 575
 576     if(lseek(fd, startpos, SEEK_SET) < 0)
 577         return -1;
 578
 579     buf_init();
 580
 581     /* Find out the total number of frames */
 582     num_frames = 0;
 583     cnt = 0;
 584
 585     while((header = buf_find_next_frame(fd, &bytes, -1, header_template))) {
 586         mp3headerinfo(&info, header);
 587
 588         if(!header_template)
 589             header_template = header;
 590
 591         /* See if this really is a VBR file */
 592         if(last_bitrate && info.bitrate != last_bitrate)
 593         {
 594             is_vbr = true;
 595         }
 596         last_bitrate = info.bitrate;
 597
 598         buf_seek(fd, info.frame_size-4);
 599         num_frames++;
 600         if(progressfunc)
 601         {
 602             cnt += bytes + info.frame_size;
 603             if(cnt > progress_chunk)
 604             {
 605                 progress_cnt++;
 606                 progressfunc(progress_cnt);
 607                 cnt = 0;
 608             }
 609         }
 610     }
 611     DEBUGF("Total number of frames: %d\n", num_frames);
 612
 613     if(is_vbr)
 614         return num_frames;
 615     else
 616     {
 617         DEBUGF("Not a VBR file\n");
 618         return 0;
 619     }
 620 }
 621
 622 static const char cooltext[] = "Rockbox - rocks your box";
 623
 624 /* buf needs to be the audio buffer with TOC generation enabled,
 625    and at least MAX_XING_HEADER_SIZE bytes otherwise */
 626 int create_xing_header(int fd, long startpos, long filesize,
 627                        unsigned char *buf, unsigned long num_frames,
 628                        unsigned long rec_time, unsigned long header_template,
 629                        void (*progressfunc)(int), bool generate_toc)
 630 {
 631     struct mp3info info;
 632     unsigned char toc[100];
 633     unsigned long header = 0;
 634     unsigned long xing_header_template = header_template;
 635     unsigned long filepos;
 636     long pos, last_pos;
 637     long j;
 638     long bytes;
 639     int i;
 640     int index;
 641
 642     DEBUGF("create_xing_header()\n");
 643
 644     if(generate_toc)
 645     {
 646         lseek(fd, startpos, SEEK_SET);
 647         buf_init();
 648
 649         /* Generate filepos table */
 650         last_pos = 0;
 651         filepos = 0;
 652         header = 0;
 653         for(i = 0;i < 100;i++) {
 654             /* Calculate the absolute frame number for this seek point */
 655             pos = i * num_frames / 100;
 656
 657             /* Advance from the last seek point to this one */
 658             for(j = 0;j < pos - last_pos;j++)
 659             {
 660                 header = buf_find_next_frame(fd, &bytes, -1, header_template);
 661                 filepos += bytes;
 662                 mp3headerinfo(&info, header);
 663                 buf_seek(fd, info.frame_size-4);
 664                 filepos += info.frame_size;
 665
 666                 if(!header_template)
 667                     header_template = header;
 668             }
 669
 670             /* Save a header for later use if header_template is empty.
 671                We only save one header, and we want to save one in the
 672                middle of the stream, just in case the first and the last
 673                headers are corrupt. */
 674             if(!xing_header_template && i == 1)
 675                 xing_header_template = header;
 676
 677             if(progressfunc)
 678             {
 679                 progressfunc(50 + i/2);
 680             }
 681
 682             /* Fill in the TOC entry */
 683             /* each toc is a single byte indicating how many 256ths of the
 684              * way through the file, is that percent of the way through the
 685              * song. the easy method, filepos*256/filesize, chokes when
 686              * the upper 8 bits of the file position are nonzero
 687              * (i.e. files over 16mb in size).
 688              */
 689             if (filepos > (ULONG_MAX/256))
 690             {
 691                 /* instead of multiplying filepos by 256, we divide
 692                  * filesize by 256.
 693                  */
 694                 toc[i] = filepos / (filesize >> 8);
 695             }
 696             else
 697             {
 698                 toc[i] = filepos * 256 / filesize;
 699             }
 700
 701             DEBUGF("Pos %d: %ld  relpos: %ld  filepos: %lx tocentry: %x\n",
 702                    i, pos, pos-last_pos, filepos, toc[i]);
 703
 704             last_pos = pos;
 705         }
 706     }
 707
 708     /* Use the template header and create a new one.
 709        We ignore the Protection bit even if the rest of the stream is
 710        protected. */
 711     header = xing_header_template & ~(BITRATE_MASK|PROTECTION_MASK|PADDING_MASK);
 712     header |= 8 << 12; /* This gives us plenty of space, 192..576 bytes */
 713
 714     if (!mp3headerinfo(&info, header))
 715         return 0;  /* invalid header */
 716
 717     if (num_frames == 0 && rec_time) {
 718         /* estimate the number of frames based on the recording time */
 719         if (rec_time <= ULONG_MAX / info.ft_den)
 720             num_frames = rec_time * info.ft_den / info.ft_num;
 721         else
 722             num_frames = rec_time / info.ft_num * info.ft_den;
 723     }
 724
 725     /* Clear the frame */
 726     memset(buf, 0, MAX_XING_HEADER_SIZE);
 727
 728     /* Write the header to the buffer */
 729     long2bytes(buf, header);
 730
 731     /* Calculate position of VBR header */
 732     if (info.version == MPEG_VERSION1) {
 733         if (info.channel_mode == 3) /* mono */
 734             index = 21;
 735         else
 736             index = 36;
 737     }
 738     else {
 739         if (info.channel_mode == 3) /* mono */
 740             index = 13;
 741         else
 742             index = 21;
 743     }
 744
 745     /* Create the Xing data */
 746     memcpy(&buf[index], "Xing", 4);
 747     long2bytes(&buf[index+4], (num_frames ? VBR_FRAMES_FLAG : 0)
 748                               | (filesize ? VBR_BYTES_FLAG : 0)
 749                               | (generate_toc ? VBR_TOC_FLAG : 0));
 750     index += 8;
 751     if(num_frames)
 752     {
 753         long2bytes(&buf[index], num_frames);
 754         index += 4;
 755     }
 756
 757     if(filesize)
 758     {
 759         long2bytes(&buf[index], filesize - startpos);
 760         index += 4;
 761     }
 762
 763     /* Copy the TOC */
 764     memcpy(buf + index, toc, 100);
 765
 766     /* And some extra cool info */
 767     memcpy(buf + index + 100, cooltext, sizeof(cooltext));
 768
 769 #ifdef DEBUG
 770     for(i = 0;i < info.frame_size;i++)
 771     {
 772         if(i && !(i % 16))
 773             DEBUGF("\n");
 774
 775         DEBUGF("%02x ", buf[i]);
 776     }
 777 #endif
 778
 779     return info.frame_size;
 780 }
 781
 782 #endif