mapping0.java

来自「java ogg player library. for play back o」· Java 代码 · 共 567 行 · 第 1/2 页

/* JOrbis
 * Copyright (C) 2000 ymnk, JCraft,Inc.
 *  
 * Written by: 2000 ymnk<[e-mail]>
 *   
 * Many thanks to 
 *   Monty <[e-mail]> and 
 *   The XIPHOPHORUS Company http://www.xiph.org/ .
 * JOrbis has been based on their awesome works, Vorbis codec.
 *   
 * This program 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 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 Library General Public License for more details.
 * 
 * You should have received a copy of the GNU Library General Public
 * License along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

package com.jcraft.jorbis;

import com.jcraft.jogg.*;

class Mapping0 extends FuncMapping{
  static int seq=0;
  void free_info(Object imap){};
  void free_look(Object imap){
/*
    LookMapping0 l=(LookMapping0)imap;
    InfoMapping0 info=l.map;
    if(l!=null){
      for(int i=0;i<l.map.submaps;i++){
        l.time_func[i].free_look(l.time_look[i]);
        l.floor_func[i].free_look(l.floor_look[i]);
        l.residue_func[i].free_look(l.residue_look[i]);
        if(l.psy_look!=null)l.psy_look[i].clear();
      }
    }

    if(l.floor_state!=null){
      for(int i=0;i<l.ch;i++)
  	l.floor_func[info.chmuxlist[i]].free_state(l.floor_state[i]);
      //free(l.floor_state);
    }

    if(l.decay!=null){
      for(int i=0;i<l.ch;i++){
	//if(l.decay[i])free(l->decay[i]);
        l.decay[i]=null;
      }
      //free(l->decay);
      l.decay=null;
    }
    //free(l->time_func);
    //free(l->floor_func);
    //free(l->residue_func);
    //free(l->time_look);
    //free(l->floor_look);
    //free(l->residue_look);
    //f(l->psy_look)free(l->psy_look);
    l.time_func=null;
    l.floor_func=null;
    l.residue_func=null;
    l.time_look=null;
    l.floor_look=null;
    l.residue_look=null;
    //memset(l,0,sizeof(vorbis_look_mapping0));
    //free(l);
*/
  }

  Object look(DspState vd, InfoMode vm, Object m){
//System.err.println("Mapping0.look");
    Info vi=vd.vi;
    LookMapping0 look=new LookMapping0();
    InfoMapping0 info=look.map=(InfoMapping0)m;
    look.mode=vm;
  
    look.time_look=new Object[info.submaps];
    look.floor_look=new Object[info.submaps];
    look.residue_look=new Object[info.submaps];

/*
    if(vd.analysisp!=0){
      look.floor_state=new Object[vi.channels];
    }
    if(vi.psys!=0){
      look.psy_look=new PsyLook[info.submaps];
      for(int i=0; i<info.submaps; i++){ look.psy_look[i]=new PsyLook(); }
    }
*/

    look.time_func=new FuncTime[info.submaps];
    look.floor_func=new FuncFloor[info.submaps];
    look.residue_func=new FuncResidue[info.submaps];
  
    for(int i=0;i<info.submaps;i++){
      int timenum=info.timesubmap[i];
      int floornum=info.floorsubmap[i];
      int resnum=info.residuesubmap[i];

      look.time_func[i]=FuncTime.time_P[vi.time_type[timenum]];
      look.time_look[i]=look.time_func[i].look(vd,vm,vi.time_param[timenum]);
      look.floor_func[i]=FuncFloor.floor_P[vi.floor_type[floornum]];
      look.floor_look[i]=look.floor_func[i].
                         look(vd,vm,vi.floor_param[floornum]);
      look.residue_func[i]=FuncResidue.residue_P[vi.residue_type[resnum]];
      look.residue_look[i]=look.residue_func[i].
                           look(vd,vm,vi.residue_param[resnum]);

/*    
      if(vi.psys!=0 && vd.analysisp!=0){
        int psynum=info.psysubmap[i];
	look.psy_look[i].init(vi.psy_param[psynum],
			      vi.blocksizes[vm.blockflag]/2,vi.rate);
      }
*/
    }

    if(vi.psys!=0 && vd.analysisp!=0){
	/*
    if(info->psy[0] != info->psy[1]){

      int psynum=info->psy[0];
      look->psy_look[0]=_ogg_calloc(1,sizeof(vorbis_look_psy));      
      _vp_psy_init(look->psy_look[0],ci->psy_param[psynum],
		   ci->psy_g_param,
		   ci->blocksizes[vm->blockflag]/2,vi->rate);

      psynum=info->psy[1];
      look->psy_look[1]=_ogg_calloc(1,sizeof(vorbis_look_psy));      
      _vp_psy_init(look->psy_look[1],ci->psy_param[psynum],
		   ci->psy_g_param,
		   ci->blocksizes[vm->blockflag]/2,vi->rate);
    }else{

      int psynum=info->psy[0];
      look->psy_look[0]=_ogg_calloc(1,sizeof(vorbis_look_psy));      
      look->psy_look[1]=look->psy_look[0];
     _vp_psy_init(look->psy_look[0],ci->psy_param[psynum],
		   ci->psy_g_param,
		   ci->blocksizes[vm->blockflag]/2,vi->rate);

    }
	*/
    }

    look.ch=vi.channels;
//  if(vd->analysisp)drft_init(&look->fft_look,ci->blocksizes[vm->blockflag]);

    return(look);
//return null;
  }

  void pack(Info vi, Object imap, Buffer opb){
    InfoMapping0 info=(InfoMapping0)imap;

  /* another 'we meant to do it this way' hack...  up to beta 4, we
     packed 4 binary zeros here to signify one submapping in use.  We
     now redefine that to mean four bitflags that indicate use of
     deeper features; bit0:submappings, bit1:coupling,
     bit2,3:reserved. This is backward compatable with all actual uses
     of the beta code. */

    if(info.submaps>1){
      opb.write(1,1);
      opb.write(info.submaps-1,4);
    }
    else{
      opb.write(0,1);
    }

    if(info.coupling_steps>0){
      opb.write(1,1);
      opb.write(info.coupling_steps-1,8);
      for(int i=0;i<info.coupling_steps;i++){
        opb.write(info.coupling_mag[i],ilog2(vi.channels));
        opb.write(info.coupling_ang[i],ilog2(vi.channels));
      }
    }
    else{
      opb.write(0,1);
    }
  
    opb.write(0,2); /* 2,3:reserved */

    /* we don't write the channel submappings if we only have one... */
    if(info.submaps>1){
      for(int i=0;i<vi.channels;i++)
        opb.write(info.chmuxlist[i],4);
    }
    for(int i=0;i<info.submaps;i++){
      opb.write(info.timesubmap[i],8);
      opb.write(info.floorsubmap[i],8);
      opb.write(info.residuesubmap[i],8);
    }
  }

  // also responsible for range checking
  Object unpack(Info vi, Buffer opb){
    InfoMapping0 info=new InfoMapping0();

    // !!!!
    if(opb.read(1)!=0){
      info.submaps=opb.read(4)+1;
    }
    else{
      info.submaps=1;
    }

    if(opb.read(1)!=0){
      info.coupling_steps=opb.read(8)+1;

      for(int i=0;i<info.coupling_steps;i++){
        int testM=info.coupling_mag[i]=opb.read(ilog2(vi.channels));
        int testA=info.coupling_ang[i]=opb.read(ilog2(vi.channels));

        if(testM<0 ||
           testA<0 ||
           testM==testA ||
           testM>=vi.channels ||
           testA>=vi.channels){
	  //goto err_out;
          info.free();
          return(null);
        }
      }
    }

    if(opb.read(2)>0){ /* 2,3:reserved */
      //goto err_out;
      info.free();
      return(null);
    }

    if(info.submaps>1){
      for(int i=0;i<vi.channels;i++){
        info.chmuxlist[i]=opb.read(4);
        if(info.chmuxlist[i]>=info.submaps){
	  //goto err_out;
          info.free();
          return(null);
	}
      }
    }

    for(int i=0;i<info.submaps;i++){
      info.timesubmap[i]=opb.read(8);
      if(info.timesubmap[i]>=vi.times){
        //goto err_out;
        info.free();
        return(null);
      }
      info.floorsubmap[i]=opb.read(8);
      if(info.floorsubmap[i]>=vi.floors){
	//goto err_out;
        info.free();
        return(null);
      }
      info.residuesubmap[i]=opb.read(8);
      if(info.residuesubmap[i]>=vi.residues){
	//goto err_out;
        info.free();
        return(null);
      }
    }
    return info;
    //err_out:
    //free_info(info);
    //return(NULL);
  }

/*
  // no time mapping implementation for now 
  static int seq=0;
  int forward(Block vb, Object l){
    DspState vd=vb.vd;
    Info vi=vd.vi;