path: root/mp3_cd.cpp

/* ScummVM - Scumm Interpreter
 * Copyright (C) 2002 The ScummVM project
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 * $Header$
 */

#include "stdafx.h"
#include "scumm.h"

#ifdef COMPRESSED_SOUND_FILE
#include "mp3_cd.h"
#include <SDL.h>

int _current_mp3_cd_track;
struct xing _vbr_header;
struct mad_header _mad_header;
long _mp3_size;
FILE *_mp3_track;
MixerChannel *_mc;

// From xing.c in MAD

int xing_parse(struct xing *xing, struct mad_bitptr ptr, unsigned int bitlen)
{

  xing->flags = 0;

  if (bitlen < 64 || mad_bit_read(&ptr, 32) != XING_MAGIC)
    goto fail;

  xing->flags = mad_bit_read(&ptr, 32);
  bitlen -= 64;

  if (xing->flags & XING_FRAMES) {
    if (bitlen < 32)
      goto fail;

    xing->frames = mad_bit_read(&ptr, 32);
    bitlen -= 32;
  }

  if (xing->flags & XING_BYTES) {
    if (bitlen < 32)
      goto fail;

    xing->bytes = mad_bit_read(&ptr, 32);
    bitlen -= 32;
  }

  if (xing->flags & XING_TOC) {
    int i;

    if (bitlen < 800)
      goto fail;

    for (i = 0; i < 100; ++i)
      xing->toc[i] = (unsigned char)mad_bit_read(&ptr, 8);

    bitlen -= 800;
  }

  if (xing->flags & XING_SCALE) {
    if (bitlen < 32)
      goto fail;

    xing->scale = mad_bit_read(&ptr, 32);
    bitlen -= 32;
  }

  return 0;

 fail:
  xing->flags = 0;
  return -1;
}

// Borrowed from Winamp plugin in_mad.c

bool parse_xing_vbr_tag()
{
  struct mad_stream stream;
  struct mad_frame frame;
  unsigned char buffer[8192];
  unsigned int buflen = 0;
  int count = 0, result = 0;

  _vbr_header.flags = 0;

  mad_stream_init(&stream);
  mad_frame_init(&frame);
  
  fseek(_mp3_track, 0, SEEK_SET);

  while (1) {
    if (buflen < sizeof(buffer)) {
      uint16 bytes;        

	  bytes = fread(buffer + buflen, 1, sizeof(buffer) - buflen, _mp3_track);
      if (bytes <= 0) {
	if (bytes == -1)
	  result = -1;
	break;
      }

      buflen += bytes;
    }

    mad_stream_buffer(&stream, buffer, buflen);

    while (1) {
      if (mad_frame_decode(&frame, &stream) == -1) {
	if (!MAD_RECOVERABLE(stream.error))
	  break;

	if (stream.error != MAD_ERROR_BADCRC)
	  continue;
      }

      if (count++ || 
		  xing_parse(&_vbr_header, stream.anc_ptr, stream.anc_bitlen) 
			== -1)
	break;
    }

    if (count || stream.error != MAD_ERROR_BUFLEN)
      break;

    memmove(buffer, stream.next_frame,
	    buflen = &buffer[buflen] - stream.next_frame);
  }

  if (count)
	  memcpy(&_mad_header, &frame.header, sizeof(mad_header));
  else
	  result = -1;

  mad_frame_finish(&frame);
  mad_stream_finish(&stream);

  return (result != -1);
}

uint32 calc_cd_file_offset(int start_frame) {
	long offset;

	if (!_vbr_header.flags) {
		float frame_size;
		//mad_timer_t timer;  - recode with timer

		/* Constant bit rate - perhaps not fully accurate */
		frame_size = 144 * _mad_header.bitrate / _mad_header.samplerate;
		offset = (long)((float)start_frame / (float)CD_FPS * 1000 / 
				 (float)((float)1152 / (float)_mad_header.samplerate * 1000) *
				 (float)(frame_size + 0.5));			
	}
	else {
        /* DOES NOT WORK AT THE MOMENT */
		/* see Xing SDK */
		long a;
		float fa, fb, fx;
		float percent = (float)start_frame / (float)CD_FPS * 1000 /
						((float)((float)1152 / (float)_mad_header.samplerate * 1000) * _vbr_header.frames) *
						100;

		if( percent < 0.0f )   percent = 0.0f;
		if( percent > 100.0f ) percent = 100.0f;

		a = (int)percent;
		if( a > 99 ) a = 99;
		fa = _vbr_header.toc[a];
		if( a < 99 ) {
			fb = _vbr_header.toc[a+1];
		}
		else {
			fb = 256.0f;
		}

		fx = fa + (fb-fa)*(percent-a);

		offset = (int)((1.0f/256.0f)*fx*_vbr_header.bytes); 

	}

	return offset;
}

bool mp3_cd_play(Scumm *s, int track, int num_loops, int start_frame, int end_frame) {

	// See if we are already playing this track, else try to open it

	if (_current_mp3_cd_track != track) {
		char track_name[1024];				

		sprintf(track_name, "%strack%d.mp3", s->_gameDataPath, track);
		_mp3_track = fopen(track_name, "rb");
		if (!_mp3_track) {
			warning("No CD and track %d not available in mp3 format", track);
                        return false;
		}

		if (!parse_xing_vbr_tag()) {
				warning("Error parsing file header - ignoring file", 
							track);
				fclose(_mp3_track);
                                return false;
		}

		if (_vbr_header.flags) {
			if (!(
				    (_vbr_header.flags & XING_TOC) &&
					(_vbr_header.flags & XING_BYTES) &&
					(_vbr_header.flags & XING_FRAMES)
				)) {
				warning("Missing required part of VBR header - ignoring file");
				fclose(_mp3_track);
				_vbr_header.flags = 0;
                                return false;
			}
		}

		// Allocate the music mixer if necessary

		if (!_mc) {
			_mc = s->allocateMixer();
			if (!_mc) {
				warning("No mixer channel available for MP3 music");
                                return false;
			}
		}

		fseek(_mp3_track, 0, SEEK_END);
		_mp3_size = ftell(_mp3_track);
		fseek(_mp3_track, 0, SEEK_SET);

		_mc->type = MIXER_MP3_CDMUSIC;
		_mc->sound_data.mp3_cdmusic.file = _mp3_track;
                _mc->sound_data.mp3_cdmusic.playing = false;
		_mc->sound_data.mp3_cdmusic.buffer_size = 200000;
		_mc->_sfx_sound = malloc(_mc->sound_data.mp3_cdmusic.buffer_size); 

														/* see if it's enough */
		mad_stream_init(&_mc->sound_data.mp3.stream);
		if (_mad_header.samplerate == 44100) 
			mad_stream_options((mad_stream*)&_mc->sound_data.mp3.stream, 
								MAD_OPTION_HALFSAMPLERATE);

		mad_frame_init(&_mc->sound_data.mp3.frame);
		mad_synth_init(&_mc->sound_data.mp3.synth);

		_current_mp3_cd_track = track;		
	}


	if (_current_mp3_cd_track == track) {

		uint32 where;

		// See where we want to go
		where = calc_cd_file_offset(start_frame);

		if (start_frame < 0 || end_frame < 0) {
			warning("Negative index in frame");
                        return false;
		}

		mad_timer_set(&_mc->sound_data.mp3_cdmusic.duration,
					  0,
					  end_frame,
					  CD_FPS);

		fseek(_mp3_track, where, SEEK_SET);
                _mc->sound_data.mp3_cdmusic.playing = true;             

                return true;
	}

        return false;
}

#endif