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