Rev 2 | Blame | Compare with Previous | Last modification | View Log | RSS feed
/*
* Xing VBR tagging for LAME.
*
* Copyright (c) 1999 A.L. Faber
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
/* $Id: VbrTag.c,v 1.20 2001/02/27 09:59:16 robert Exp $ */
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include "machine.h"
#if defined(__riscos__) && defined(FPA10)
#include "ymath.h"
#else
#include <math.h>
#endif
#include "VbrTag.h"
#include "version.h"
#include "bitstream.h"
#include "VbrTag.h"
#include <assert.h>
#ifdef WITH_DMALLOC
#include <dmalloc.h>
#endif
#ifdef _DEBUG
/* #define DEBUG_VBRTAG */
#endif
/*
// 4 bytes for Header Tag
// 4 bytes for Header Flags
// 100 bytes for entry (NUMTOCENTRIES)
// 4 bytes for FRAME SIZE
// 4 bytes for STREAM_SIZE
// 4 bytes for VBR SCALE. a VBR quality indicator: 0=best 100=worst
// 20 bytes for LAME tag. for example, "LAME3.12 (beta 6)"
// ___________
// 140 bytes
*/
#define VBRHEADERSIZE (NUMTOCENTRIES+4+4+4+4+4)
/* the size of the Xing header (MPEG1 and MPEG2) in kbps */
#define XING_BITRATE1 128
#define XING_BITRATE2 64
#define XING_BITRATE25 32
const static char VBRTag[]={"Xing"};
const int SizeOfEmptyFrame[2][2]=
{
{17,9},
{32,17},
};
/***********************************************************************
* Robert Hegemann 2001-01-17
***********************************************************************/
void addVbr(VBR_seek_info_t * v, int bitrate)
{
int i;
v->sum += bitrate;
v->seen ++;
if (v->seen < v->want) {
return;
}
if (v->pos < v->size) {
v->bag[v->pos] = v->sum;
v->pos ++;
v->seen = 0;
}
if (v->pos == v->size) {
for (i = 1; i < v->size; i += 2) {
v->bag[i/2] = v->bag[i];
}
v->want *= 2;
v->pos /= 2;
}
}
void Xing_seek_table(VBR_seek_info_t * v, unsigned char *t)
{
int i, index;
int seek_point;
if (v->pos <= 0)
return;
for (i = 1; i < NUMTOCENTRIES; ++i) {
float j = i/(float)NUMTOCENTRIES, act, sum;
index = (int)(floor(j * v->pos));
if (index > v->pos-1)
index = v->pos-1;
act = v->bag[index];
sum = v->sum;
seek_point = (int)(256. * act / sum);
if (seek_point > 255)
seek_point = 255;
t[i] = seek_point;
}
}
#if 0
void print_seeking(unsigned char *t)
{
int i;
printf("seeking table ");
for (i = 0; i < NUMTOCENTRIES; ++i) {
printf(" %d ", t[i]);
}
printf("\n");
}
#endif
/****************************************************************************
* AddVbrFrame: Add VBR entry, used to fill the VBR the TOC entries
* Paramters:
* nStreamPos: how many bytes did we write to the bitstream so far
* (in Bytes NOT Bits)
****************************************************************************
*/
void AddVbrFrame(lame_global_flags *gfp)
{
lame_internal_flags *gfc = gfp->internal_flags;
int kbps = bitrate_table[gfp->version][gfc->bitrate_index];
if (gfc->VBR_seek_table.bag == NULL) {
gfc->VBR_seek_table.sum = 0;
gfc->VBR_seek_table.seen = 0;
gfc->VBR_seek_table.want = 1;
gfc->VBR_seek_table.pos = 0;
gfc->VBR_seek_table.bag = malloc (400*sizeof(int));
if (gfc->VBR_seek_table.bag != NULL) {
gfc->VBR_seek_table.size = 400;
}
else {
gfc->VBR_seek_table.size = 0;
ERRORF (gfc,"Error: can't allocate VbrFrames buffer\n");
return;
}
}
addVbr(&gfc->VBR_seek_table, kbps);
gfp->nVbrNumFrames++;
}
/*-------------------------------------------------------------*/
static int ExtractI4(unsigned char *buf)
{
int x;
/* big endian extract */
x = buf[0];
x <<= 8;
x |= buf[1];
x <<= 8;
x |= buf[2];
x <<= 8;
x |= buf[3];
return x;
}
void CreateI4(unsigned char *buf, int nValue)
{
/* big endian create */
buf[0]=(nValue>>24)&0xff;
buf[1]=(nValue>>16)&0xff;
buf[2]=(nValue>> 8)&0xff;
buf[3]=(nValue )&0xff;
}
/*-------------------------------------------------------------*/
/* Same as GetVbrTag below, but only checks for the Xing tag.
requires buf to contain only 40 bytes */
/*-------------------------------------------------------------*/
int CheckVbrTag(unsigned char *buf)
{
int h_id, h_mode, h_sr_index;
/* get selected MPEG header data */
h_id = (buf[1] >> 3) & 1;
h_sr_index = (buf[2] >> 2) & 3;
h_mode = (buf[3] >> 6) & 3;
/* determine offset of header */
if( h_id )
{
/* mpeg1 */
if( h_mode != 3 ) buf+=(32+4);
else buf+=(17+4);
}
else
{
/* mpeg2 */
if( h_mode != 3 ) buf+=(17+4);
else buf+=(9+4);
}
if( buf[0] != VBRTag[0] ) return 0; /* fail */
if( buf[1] != VBRTag[1] ) return 0; /* header not found*/
if( buf[2] != VBRTag[2] ) return 0;
if( buf[3] != VBRTag[3] ) return 0;
return 1;
}
int GetVbrTag(VBRTAGDATA *pTagData, unsigned char *buf)
{
int i, head_flags;
int h_bitrate,h_id, h_mode, h_sr_index;
/* get Vbr header data */
pTagData->flags = 0;
/* get selected MPEG header data */
h_id = (buf[1] >> 3) & 1;
h_sr_index = (buf[2] >> 2) & 3;
h_mode = (buf[3] >> 6) & 3;
h_bitrate = ((buf[2]>>4)&0xf);
h_bitrate = bitrate_table[h_id][h_bitrate];
/* determine offset of header */
if( h_id )
{
/* mpeg1 */
if( h_mode != 3 ) buf+=(32+4);
else buf+=(17+4);
}
else
{
/* mpeg2 */
if( h_mode != 3 ) buf+=(17+4);
else buf+=(9+4);
}
if( buf[0] != VBRTag[0] ) return 0; /* fail */
if( buf[1] != VBRTag[1] ) return 0; /* header not found*/
if( buf[2] != VBRTag[2] ) return 0;
if( buf[3] != VBRTag[3] ) return 0;
buf+=4;
pTagData->h_id = h_id;
pTagData->samprate = samplerate_table[h_id][h_sr_index];
if( h_id == 0 )
pTagData->samprate >>= 1;
head_flags = pTagData->flags = ExtractI4(buf); buf+=4; /* get flags */
if( head_flags & FRAMES_FLAG )
{
pTagData->frames = ExtractI4(buf); buf+=4;
}
if( head_flags & BYTES_FLAG )
{
pTagData->bytes = ExtractI4(buf); buf+=4;
}
if( head_flags & TOC_FLAG )
{
if( pTagData->toc != NULL )
{
for(i=0;i<NUMTOCENTRIES;i++)
pTagData->toc[i] = buf[i];
}
buf+=NUMTOCENTRIES;
}
pTagData->vbr_scale = -1;
if( head_flags & VBR_SCALE_FLAG )
{
pTagData->vbr_scale = ExtractI4(buf); buf+=4;
}
pTagData->headersize =
((h_id+1)*72000*h_bitrate) / pTagData->samprate;
#ifdef DEBUG_VBRTAG
DEBUGF("\n\n********************* VBR TAG INFO *****************\n");
DEBUGF("tag :%s\n",VBRTag);
DEBUGF("head_flags :%d\n",head_flags);
DEBUGF("bytes :%d\n",pTagData->bytes);
DEBUGF("frames :%d\n",pTagData->frames);
DEBUGF("VBR Scale :%d\n",pTagData->vbr_scale);
DEBUGF("toc:\n");
if( pTagData->toc != NULL )
{
for(i=0;i<NUMTOCENTRIES;i++)
{
if( (i%10) == 0 ) DEBUGF("\n");
DEBUGF(" %3d", (int)(pTagData->toc[i]));
}
}
DEBUGF("\n***************** END OF VBR TAG INFO ***************\n");
#endif
return 1; /* success */
}
/****************************************************************************
* InitVbrTag: Initializes the header, and write empty frame to stream
* Paramters:
* fpStream: pointer to output file stream
* nMode : Channel Mode: 0=STEREO 1=JS 2=DS 3=MONO
****************************************************************************
*/
int InitVbrTag(lame_global_flags *gfp)
{
int nMode,SampIndex;
lame_internal_flags *gfc = gfp->internal_flags;
#define MAXFRAMESIZE 576
// u_char pbtStreamBuffer[MAXFRAMESIZE];
nMode = gfp->mode;
SampIndex = gfc->samplerate_index;
/* Clear Frame position array variables */
gfp->pVbrFrames=NULL;
gfp->nVbrNumFrames=0;
gfp->nVbrFrameBufferSize=0;
/* Clear stream buffer */
// memset(pbtStreamBuffer,0x00,sizeof(pbtStreamBuffer));
/* Reserve the proper amount of bytes */
if (nMode==3)
{
gfp->nZeroStreamSize=SizeOfEmptyFrame[gfp->version][1]+4;
}
else
{
gfp->nZeroStreamSize=SizeOfEmptyFrame[gfp->version][0]+4;
}
/*
// Xing VBR pretends to be a 48kbs layer III frame. (at 44.1kHz).
// (at 48kHz they use 56kbs since 48kbs frame not big enough for
// table of contents)
// let's always embed Xing header inside a 64kbs layer III frame.
// this gives us enough room for a LAME version string too.
// size determined by sampling frequency (MPEG1)
// 32kHz: 216 bytes@48kbs 288bytes@ 64kbs
// 44.1kHz: 156 bytes 208bytes@64kbs (+1 if padding = 1)
// 48kHz: 144 bytes 192
//
// MPEG 2 values are the same since the framesize and samplerate
// are each reduced by a factor of 2.
*/
{
int i,bitrate,tot;
if (1==gfp->version) {
bitrate = XING_BITRATE1;
} else {
if (gfp->out_samplerate < 16000 )
bitrate = XING_BITRATE25;
else
bitrate = XING_BITRATE2;
}
gfp->TotalFrameSize=
((gfp->version+1)*72000*bitrate) / gfp->out_samplerate;
tot = (gfp->nZeroStreamSize+VBRHEADERSIZE);
tot += 20; /* extra 20 bytes for LAME & version string */
assert(gfp->TotalFrameSize >= tot );
assert(gfp->TotalFrameSize <= MAXFRAMESIZE );
for (i=0; i<gfp->TotalFrameSize; ++i)
add_dummy_byte(gfp,0);
}
/* Success */
return 0;
}
/****************************************************************************
* PutVbrTag: Write final VBR tag to the file
* Paramters:
* lpszFileName: filename of MP3 bit stream
* nVbrScale : encoder quality indicator (0..100)
****************************************************************************
*/
int PutVbrTag(lame_global_flags *gfp,FILE *fpStream,int nVbrScale)
{
lame_internal_flags * gfc = gfp->internal_flags;
long lFileSize;
int nStreamIndex;
char abyte,bbyte;
u_char btToc[NUMTOCENTRIES];
u_char pbtStreamBuffer[MAXFRAMESIZE];
char str1[80];
unsigned char id3v2Header[10];
size_t id3v2TagSize;
if (gfc->VBR_seek_table.pos <= 0)
return -1;
/* Clear stream buffer */
memset(pbtStreamBuffer,0x00,sizeof(pbtStreamBuffer));
/* Seek to end of file*/
fseek(fpStream,0,SEEK_END);
/* Get file size */
lFileSize=ftell(fpStream);
/* Abort if file has zero length. Yes, it can happen :) */
if (lFileSize==0)
return -1;
/*
* The VBR tag may NOT be located at the beginning of the stream.
* If an ID3 version 2 tag was added, then it must be skipped to write
* the VBR tag data.
*/
/* seek to the beginning of the stream */
fseek(fpStream,0,SEEK_SET);
/* read 10 bytes in case there's an ID3 version 2 header here */
fread(id3v2Header,1,sizeof id3v2Header,fpStream);
/* does the stream begin with the ID3 version 2 file identifier? */
if (!strncmp((char *)id3v2Header,"ID3",3)) {
/* the tag size (minus the 10-byte header) is encoded into four
* bytes where the most significant bit is clear in each byte */
id3v2TagSize=(((id3v2Header[6] & 0x7f)<<21)
| ((id3v2Header[7] & 0x7f)<<14)
| ((id3v2Header[8] & 0x7f)<<7)
| (id3v2Header[9] & 0x7f))
+ sizeof id3v2Header;
} else {
/* no ID3 version 2 tag in this stream */
id3v2TagSize=0;
}
/* Seek to first real frame */
fseek(fpStream,id3v2TagSize+gfp->TotalFrameSize,SEEK_SET);
/* Read the header (first valid frame) */
fread(pbtStreamBuffer,4,1,fpStream);
/* the default VBR header. 48 kbps layer III, no padding, no crc */
/* but sampling freq, mode andy copyright/copy protection taken */
/* from first valid frame */
pbtStreamBuffer[0]=(u_char) 0xff;
abyte = (pbtStreamBuffer[1] & (char) 0xf1);
{ int bitrate;
if (1==gfp->version) {
bitrate = XING_BITRATE1;
} else {
if (gfp->out_samplerate < 16000 )
bitrate = XING_BITRATE25;
else
bitrate = XING_BITRATE2;
}
bbyte = 16*BitrateIndex(bitrate,gfp->version,gfp->out_samplerate);
}
/* Use as much of the info from the real frames in the
* Xing header: samplerate, channels, crc, etc...
*/
if (gfp->version==1) {
/* MPEG1 */
pbtStreamBuffer[1]=abyte | (char) 0x0a; /* was 0x0b; */
abyte = pbtStreamBuffer[2] & (char) 0x0d; /* AF keep also private bit */
pbtStreamBuffer[2]=(char) bbyte | abyte; /* 64kbs MPEG1 frame */
}else{
/* MPEG2 */
pbtStreamBuffer[1]=abyte | (char) 0x02; /* was 0x03; */
abyte = pbtStreamBuffer[2] & (char) 0x0d; /* AF keep also private bit */
pbtStreamBuffer[2]=(char) bbyte | abyte; /* 64kbs MPEG2 frame */
}
/*Seek to the beginning of the stream */
fseek(fpStream,id3v2TagSize,SEEK_SET);
/* Clear all TOC entries */
memset(btToc,0,sizeof(btToc));
Xing_seek_table (&gfc->VBR_seek_table, btToc);
/* print_seeking (btToc); */
/* Start writing the tag after the zero frame */
nStreamIndex=gfp->nZeroStreamSize;
/* Put Vbr tag */
pbtStreamBuffer[nStreamIndex++]=VBRTag[0];
pbtStreamBuffer[nStreamIndex++]=VBRTag[1];
pbtStreamBuffer[nStreamIndex++]=VBRTag[2];
pbtStreamBuffer[nStreamIndex++]=VBRTag[3];
/* Put header flags */
CreateI4(&pbtStreamBuffer[nStreamIndex],FRAMES_FLAG+BYTES_FLAG+TOC_FLAG+VBR_SCALE_FLAG);
nStreamIndex+=4;
/* Put Total Number of frames */
CreateI4(&pbtStreamBuffer[nStreamIndex],gfp->nVbrNumFrames);
nStreamIndex+=4;
/* Put Total file size */
CreateI4(&pbtStreamBuffer[nStreamIndex],(int)lFileSize);
nStreamIndex+=4;
/* Put TOC */
memcpy(&pbtStreamBuffer[nStreamIndex],btToc,sizeof(btToc));
nStreamIndex+=sizeof(btToc);
/* Put VBR SCALE */
CreateI4(&pbtStreamBuffer[nStreamIndex],nVbrScale);
nStreamIndex+=4;
/* Put LAME ID */
sprintf ( str1, "LAME%s", get_lame_short_version () );
strncpy ( (char*)pbtStreamBuffer + nStreamIndex, str1, 20 );
nStreamIndex += 20;
#ifdef DEBUG_VBRTAG
{
VBRTAGDATA TestHeader;
GetVbrTag(&TestHeader,pbtStreamBuffer);
}
#endif
/* Put it all to disk again */
if (fwrite(pbtStreamBuffer,(unsigned int)gfp->TotalFrameSize,1,fpStream)!=1)
{
return -1;
}
/* Save to delete the frame buffer */
free(gfp->pVbrFrames);
gfp->pVbrFrames=NULL;
return 0; /* success */
}