Source file: /~heha/hs/puh.zip/set_get.cpp

/* set/get functions for lame_global_flags
 * Copyright (c) 2001-2005 Alexander Leidinger
 */

#include "lame.h"
#include "machine.h"
#include "encoder.h"
#include "util.h"
#include "bitstream.h"  /* because of compute_flushbits */

#include "set_get.h"
#include "lame_global_flags.h"

/*
 * input stream description
 */
#define FUNC(r,n) r n

/* number of samples */
/* it's unlikely for this function to return an error */
FUNC(int,lame_set_num_samples) (lame_global_flags&L, unsigned long n) {
  if (!L.is_valid()) return -1;
  L.set_num_samples(n);    /* default = 2^32-1 */
  return 0;
}

FUNC(unsigned long,lame_get_num_samples) (const lame_global_flags&L) {
  if (!L.is_valid()) return 0;
  return L.get_num_samples();
}

/* input samplerate */
FUNC(int,lame_set_in_samplerate) (lame_global_flags&L,int n) {
  if (!L.is_valid()) return -1;
  if (n < 1) return -1;
        /* input sample rate in Hz,  default = 44100 Hz */
  L.set_in_samplerate(n);
  return 0;
}

FUNC(int,lame_get_in_samplerate) (const lame_global_flags&L) {
  if (!L.is_valid()) return 0;
  return L.get_in_samplerate();
}

/* number of channels in input stream */
FUNC(int,lame_set_num_channels) (lame_global_flags&L,int n) {
  if (!L.is_valid()) return -1;
  if (n<1) return -1;
  if (n>2) return -1;        /* default = 2 */
  L.set_num_channels(n);
  return 0;
}

FUNC(int,lame_get_num_channels) (const lame_global_flags&L) {
  if (!L.is_valid()) return 0;
  return L.get_num_channels();
}

/* scale the input by this amount before encoding (not used for decoding) */
FUNC(int,lame_set_scale) (lame_global_flags&L,float v) {
  if (!L.is_valid()) return -1;
  L.set_scale(v);	/* default = 1 */
  return 0;
}

FUNC(float,lame_get_scale) (const lame_global_flags&L) {
  if (!L.is_valid()) return 0;
  return L.get_scale();
}


/* scale the channel 0 (left) input by this amount before 
   encoding (not used for decoding) */
int lame_global_flags::lame_set_scale_left(float v) {
  if (is_valid()) {
        /* default = 1 */
    scale_left = v;
    return 0;
  }
  return -1;
}

float lame_global_flags::lame_get_scale_left() const {
  if (is_valid()) return scale_left;
  return 0;
}

/* scale the channel 1 (right) input by this amount before 
   encoding (not used for decoding) */
int lame_global_flags::lame_set_scale_right(float v) {
  if (is_valid()) {
        /* default = 1 */
    scale_right = v;
    return 0;
  }
  return -1;
}

float lame_global_flags::lame_get_scale_right() const {
  if (is_valid()) return scale_right;
  return 0;
}

/* output sample rate in Hz */
FUNC(int,lame_set_out_samplerate) (lame_global_flags&L,int n) {
 if (!L.is_valid()) return -1;
        /*
         * default = 0: LAME picks best value based on the amount
         *              of compression
         * MPEG only allows:
         *  MPEG1    32, 44.1,   48khz
         *  MPEG2    16, 22.05,  24
         *  MPEG2.5   8, 11.025, 12
         *
         * (not used by decoding routines)
         */
  if (n && SmpFrqIndex(n)<0) return -1;
  L.set_out_samplerate(n);
  return 0;
}

FUNC(int,lame_get_out_samplerate) (const lame_global_flags&L) {
  if (!L.is_valid()) return 0;
  return L.get_out_samplerate();
}

/*
 * general control parameters
 */

/* collect data for an MP3 frame analzyer */
int
lame_set_analysis(lame_global_flags & gfp, int analysis)
{
    if (gfp.is_valid()) {
        /* default = 0 */

        /* enforce disable/enable meaning, if we need more than two values
           we need to switch to an enum to have an apropriate representation
           of the possible meanings of the value */
        if (0 > analysis || 1 < analysis)
            return -1;
        gfp.analysis = analysis;
        return 0;
    }
    return -1;
}

int
lame_get_analysis(const lame_global_flags & gfp)
{
    if (gfp.is_valid()) {
        assert(0 <= gfp.analysis && 1 >= gfp.analysis);
        return gfp.analysis;
    }
    return 0;
}



/* set and get some gapless encoding flags */



/********************************************************************
 * Filtering control
 ***********************************************************************/

/*
 * psycho acoustics and other arguments which you should not change 
 * unless you know what you are doing
 */


/*
 * Allow blocktypes to differ between channels.
 * default:
 *  0 for jstereo => block types coupled
 *  1 for stereo  => block types may differ
 */
int lame_global_flags::lame_set_allow_diff_short(bool k) {
  if (!is_valid()) return -1;
  short_blocks = k ? short_block_allowed : short_block_coupled;
  return 0;
}

bool lame_global_flags::lame_get_allow_diff_short()const{
  if (is_valid()) return short_blocks == short_block_allowed;
   /* true = short blocks allowed to differ */
   /* false = not set, dispensed, forced or coupled */
  return false;
}


/* Use temporal masking effect */
int lame_global_flags::lame_set_useTemporal(int k) {
  if (!is_valid()) return -1;
        /* default = 1 (enabled) */

        /* enforce disable/enable meaning, if we need more than two values
           we need to switch to an enum to have an apropriate representation
           of the possible meanings of the value */
  if (0 <= k && k <= 1) {
    useTemporal = k;
    return 0;
  }
  return -1;
}

int lame_global_flags::lame_get_useTemporal()const{
  if (is_valid()) {
    assert(0 <= useTemporal && 1 >= useTemporal);
    return useTemporal;
  }
  return 0;
}


/* Use inter-channel masking effect */
int lame_global_flags::lame_set_interChRatio(float ratio) {
  if (is_valid()) {
        /* default = 0.0 (no inter-channel maskin) */
    if (0 <= ratio && ratio <= 1.0) {
      interChRatio = ratio;
      return 0;
    }
  }
  return -1;
}

float lame_global_flags::lame_get_interChRatio()const{
  if (is_valid()) {
    assert((0 <= interChRatio && interChRatio <= 1.0) || EQ(interChRatio, -1.0f));
    return interChRatio;
  }
  return 0;
}


/* Use pseudo substep shaping method */
int lame_global_flags::lame_set_substep(int method) {
  if (is_valid()) {
        /* default = 0.0 (no substep noise shaping) */
    if (0 <= method && method <= 7) {
      substep_shaping = method;
      return 0;
    }
  }
  return -1;
}

int lame_global_flags::lame_get_substep()const{
  if (is_valid()) {
    assert(0 <= substep_shaping && substep_shaping <= 7);
    return substep_shaping;
  }
  return 0;
}

/* scalefactors scale */
int lame_global_flags::lame_set_sfscale(bool val) {
  if (!is_valid()) return -1;
  noise_shaping = val ? 2 : 1;
  return 0;
}

bool lame_global_flags::lame_get_sfscale()const{
  if (is_valid()) return noise_shaping == 2;
  return false;
}

/* subblock gain */
int lame_set_subblock_gain(lame_global_flags & gfp, int sbgain) {
    if (gfp.is_valid()) {
        gfp.subblock_gain = sbgain;
        return 0;
    }
    return -1;
}

int lame_get_subblock_gain(const lame_global_flags & gfp) {
    if (gfp.is_valid()) {
        return gfp.subblock_gain;
    }
    return 0;
}


/* Disable short blocks. */
int lame_set_no_short_blocks(lame_global_flags & gfp, int no_short_blocks) {
    if (gfp.is_valid()) {
        /* enforce disable/enable meaning, if we need more than two values
           we need to switch to an enum to have an apropriate representation
           of the possible meanings of the value */
        if (0 <= no_short_blocks && no_short_blocks <= 1) {
            gfp.short_blocks = no_short_blocks ? short_block_dispensed : short_block_allowed;
            return 0;
        }
    }
    return -1;
}

int lame_global_flags::lame_get_no_short_blocks()const{
  switch (short_blocks) {
    case short_block_dispensed:	return 1;
    case short_block_allowed:
    case short_block_coupled:
    case short_block_forced:	return 0;
    default:			return -1;
  }
}


/* Force short blocks. */
int lame_set_force_short_blocks(lame_global_flags & gfp, int short_blocks) {
    if (gfp.is_valid()) {
        /* enforce disable/enable meaning, if we need more than two values
           we need to switch to an enum to have an apropriate representation
           of the possible meanings of the value */
        if (0 > short_blocks || 1 < short_blocks)
            return -1;

        if (short_blocks == 1)
            gfp.short_blocks = short_block_forced;
        else if (gfp.short_blocks == short_block_forced)
            gfp.short_blocks = short_block_allowed;

        return 0;
    }
    return -1;
}

int lame_global_flags::lame_get_force_short_blocks()const{
  switch (short_blocks) {
    case short_block_dispensed:
    case short_block_allowed:
    case short_block_coupled:	return 0;
    case short_block_forced:    return 1;
    default:			return -1;
  }
}

void lame_global_flags::lame_set_short_threshold(float lrm, float s) {
  lame_set_short_threshold_lrm(lrm);
  lame_set_short_threshold_s(s);
}


/***************************************************************/
/* internal variables, cannot be set...                        */
/* provided because they may be of use to calling application  */
/***************************************************************/

/* MPEG version.
 *  0 = MPEG-2
 *  1 = MPEG-1
 * (2 = MPEG-2.5)    
 */
int lame_global_flags::lame_get_version()const{
  return internal_flags->cfg.version;
}

/* Encoder delay. */
int lame_global_flags::lame_get_encoder_delay()const{
  return internal_flags->ov_enc.encoder_delay;
}

/* padding added to the end of the input */
int lame_global_flags::lame_get_encoder_padding()const{
  return internal_flags->ov_enc.encoder_padding;
}

/* Size of MPEG frame. */
int lame_global_flags::lame_get_framesize()const{
//  if (!gfp.is_valid()) return 0;
//  lame_internal_flags const & gfc = *gfp.i;
//  if (!gfc.is_valid()) return 0;
//  SessionConfig_t const & cfg = gfc.cfg;
  return 576 * internal_flags->cfg.mode_gr;
}

/* Number of frames encoded so far. */
int lame_global_flags::lame_get_frameNum()const{
  return internal_flags->ov_enc.frame_number;
}

int lame_global_flags::lame_get_mf_samples_to_encode()const{
  return internal_flags->sv_enc.mf_samples_to_encode;
}

int lame_global_flags::lame_get_size_mp3buffer()const{
  int     size;
  internal_flags->compute_flushbits(&size);
  return size;
}

int lame_global_flags::lame_get_RadioGain()const{
  return internal_flags->ov_rpg.RadioGain;
}

int lame_global_flags::lame_get_AudiophileGain()const{
  return 0;
}

float lame_global_flags::lame_get_PeakSample()const{
  return internal_flags->ov_rpg.PeakSample;
}

int lame_global_flags::lame_get_noclipGainChange()const{
  return internal_flags->ov_rpg.noclipGainChange;
}

float lame_global_flags::lame_get_noclipScale()const{
  return internal_flags->ov_rpg.noclipScale;
}

/*
 * LAME's estimate of the total number of frames to be encoded.
 * Only valid if calling program set num_samples.
 */
int lame_global_flags::lame_get_totalframes()const{
  lame_internal_flags const &gfc = *internal_flags;
  SessionConfig_t const &cfg = gfc.cfg;
  unsigned long const pcm_samples_per_frame = 576 * cfg.mode_gr;
  unsigned long pcm_samples_to_encode = num_samples;
  unsigned long end_padding = 0;
  int frames = 0;

  if (pcm_samples_to_encode == (0ul-1ul)) return 0; /* unknown */
            /* estimate based on user set num_samples: */
  if (cfg.samplerate_in != cfg.samplerate_out) {
                /* resampling, estimate new samples_to_encode */
    double resampled_samples_to_encode = 0.0, frames_f = 0.0;
    if (cfg.samplerate_in > 0) {
      resampled_samples_to_encode = pcm_samples_to_encode;
      resampled_samples_to_encode *= cfg.samplerate_out;
      resampled_samples_to_encode /= cfg.samplerate_in;
    }
    if (resampled_samples_to_encode <= 0.0) return 0; /* unlikely to happen, so what, no estimate! */
    frames_f = floor(resampled_samples_to_encode / pcm_samples_per_frame);
    if (frames_f >= (INT_MAX-2)) return 0; /* overflow, happens eventually, no estimate! */
    frames = frames_f;
    resampled_samples_to_encode -= frames * pcm_samples_per_frame;
    pcm_samples_to_encode = ceil(resampled_samples_to_encode);
  }else{
    frames = pcm_samples_to_encode / pcm_samples_per_frame;
    pcm_samples_to_encode -= frames * pcm_samples_per_frame;
  }
  pcm_samples_to_encode += 576ul;
  end_padding = pcm_samples_per_frame - (pcm_samples_to_encode % pcm_samples_per_frame);
  if (end_padding < 576ul) end_padding += pcm_samples_per_frame;
  pcm_samples_to_encode += end_padding;
  frames += (pcm_samples_to_encode / pcm_samples_per_frame);
            /* check to see if we underestimated totalframes */
            /*    if (totalframes < gfp.frameNum) */
            /*        totalframes = gfp.frameNum; */
  return frames;
}

int lame_global_flags::lame_set_preset(int k) {
  if (is_valid()) {
    preset = k;
    return apply_preset(k,true);
  }
  return -1;
}



void lame_global_flags::lame_set_asm_optimizations(int optim, bool mode) {
  switch (optim) {
    case MMX:		asm_optimizations.mmx = mode; break;
    case AMD_3DNOW:	asm_optimizations.amd3dnow = mode; break;
    case SSE:		asm_optimizations.sse = mode; break;
  }
}


int lame_internal_flags::calc_maximum_input_samples_for_buffer_size(size_t buffer_size)const{
//  SessionConfig_t const & cfg = gfc.cfg;
  int const pcm_samples_per_frame = 576 * cfg.mode_gr;
  int     frames_per_buffer = 0, input_samples_per_buffer = 0;
  int     kbps = 320;

  if (cfg.samplerate_out < 16000) kbps = 64;
  else if (cfg.samplerate_out < 32000) kbps = 160;
  else kbps = 320;
  if (cfg.free_format) kbps = cfg.avg_bitrate;
  else if (cfg.vbr == vbr_off) kbps = cfg.avg_bitrate;
  {
    int const pad = 1;
    int const bpf = ((cfg.version + 1) * 72000 * kbps / cfg.samplerate_out + pad);
    frames_per_buffer = int(buffer_size / bpf);
  }
  {
    double ratio = (double) cfg.samplerate_in / cfg.samplerate_out;
    input_samples_per_buffer = pcm_samples_per_frame * frames_per_buffer * ratio;
  }
  return input_samples_per_buffer;
}

int lame_global_flags::lame_get_maximum_number_of_samples(size_t buffer_size) {
  return internal_flags->calc_maximum_input_samples_for_buffer_size(buffer_size);
}
Detected encoding: ASCII (7 bit)2