チェンジセット 4 : trunk/src/org/rayflood/mikuvat/io/vsq/VSQFile.java

更新日時:

2010/05/11 20:15:55 (2 年 前)

更新者:

h

ログメッセージ:

refs #2 #8 #9 #7 #6
現状のソースをコミット。一部完了。一部未完了。
関連づいてない完了チケットのチェンジセットもまとめて。
パッケージ階層も大幅に変更。

パス:

trunk/src/org/rayflood/mikuvat/io/vsq

ファイル:

• . (追加)
• VSQFile.java (移動) (移動元: trunk/src/org/rayflood/mikuvat/io/VSQFile.java) (17 diff)

trunk/src/org/rayflood/mikuvat/io/vsq/VSQFile.java

@@ -1 @@
-package org.rayflood.mikuvat.io;
-
-import static org.rayflood.mikuvat.io.VSQDecoder.decode;
-import static org.rayflood.mikuvat.io.VSQDecoder.encode;
-import static org.rayflood.mikuvat.io.VSQDecoder.setSectionBracket;
-
+package org.rayflood.mikuvat.io.vsq;
+
+import static org.rayflood.mikuvat.Utilities.setSectionBracket;
+
+import java.io.BufferedReader;
 import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.StringReader;
+import java.nio.charset.Charset;
 import java.util.ArrayList;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
-
-import javax.sound.midi.MidiEvent;
-import javax.sound.midi.MidiSystem;
+import java.util.regex.Pattern;
+
+import javax.sound.midi.InvalidMidiDataException;
 import javax.sound.midi.Sequence;
-import javax.sound.midi.Track;
-
-public class VSQFile extends ImmutableObject{
+
+import org.rayflood.mikuvat.io.BaseObject;
+import org.rayflood.mikuvat.io.InvalidBaseObjectException;
+import org.rayflood.mikuvat.io.midi.MidiData;
+import org.rayflood.mikuvat.io.midi.MidiFile;
+import org.rayflood.mikuvat.io.midi.MidiMeta;
+import org.rayflood.mikuvat.io.midi.MidiTrack;
+
+public class VSQFile extends MidiFile{
         private static final long serialVersionUID = -6314152290164983853L;
+        public static final Pattern MMHEADER = Pattern.compile("^DM:\\d+:");
+        public static final Charset WIN31J = Charset.forName("Windows-31J");
+        public static final Pattern SECTIONLINE = Pattern.compile("^\\[.+\\]$");
+        public static final int TEXTLENGTH = 119;
         public static final String COMMON = "Common";
         public static final String MASTER = "Master";
@@ -22 +36 @@
         public static final String EVENTLIST = "EventList";
 
-        private File vsqFile;
-        private Integer fileType;
-        private Float divisionType;
-        private Integer resolution;
-        private MidiTrack conductor;
         private MasterSection master;
         private MixerSection mixer;
         private ArrayList<VSQTrack> tracks;
 
-        public VSQFile(String vsq) throws Exception{
+        public VSQFile(String vsq) throws IOException, InvalidMidiDataException{
                 this();
-                readVSQFile(vsq);
-        }
-
-        public VSQFile(File vsq) throws Exception{
+                readMidiFile(vsq);
+                setVSQSequence(getMidiTracks());
+        }
+
+        public VSQFile(File vsq) throws IOException, InvalidMidiDataException{
                 this();
-                readVSQFile(vsq);
-        }
-
-        public VSQFile(Sequence sq) throws Exception{
+                readMidiFile(vsq);
+                setVSQSequence(getMidiTracks());
+        }
+
+        public VSQFile(Sequence sq) throws IOException{
                 this();
-                setVSQSequence(sq);
-        }
-
-        public void readVSQFile(String vsq) throws Exception{
+                setMidiSequence(sq);
+                setVSQSequence(getMidiTracks());
+        }
+
+        public void readVSQFile(String vsq) throws IOException, InvalidMidiDataException{
                 readVSQFile(new File(vsq));
         }
 
-        public void readVSQFile(File vsq) throws Exception{
-                setVsqFile(vsq);
-                setVSQSequence(MidiSystem.getSequence(getVsqFile()));
-        }
-
-        public void writeVSQFile() throws Exception{
+        public void readVSQFile(File vsq) throws IOException, InvalidMidiDataException{
+                super.readMidiFile(vsq);
+                setVSQSequence(getMidiTracks());
+        }
+
+        public void writeVSQFile() throws IOException, InvalidMidiDataException, InvalidBaseObjectException{
                 writeVSQFile(getVsqFile());
         }
 
-        public void writeVSQFile(String vsq) throws Exception{
+        public void writeVSQFile(String vsq) throws IOException, InvalidMidiDataException, InvalidBaseObjectException{
                 writeVSQFile(new File(vsq));
         }
 
-        public void writeVSQFile(File vsq) throws Exception{
-                MidiSystem.write(getVSQSequence(), getFileType(), vsq);
-        }
-
-        public void setVSQSequence(Sequence sq) throws Exception{
-                setFileType(MidiSystem.getMidiFileTypes(sq)[0]);
-                setDivisionType(sq.getDivisionType());
-                setResolution(sq.getResolution());
-                Track t[] = sq.getTracks();
-                setConductor(t[0]);
-
-                Map<String, List<String>> sections = decode(t[1]);
+        public void writeVSQFile(File vsq) throws IOException, InvalidMidiDataException, InvalidBaseObjectException{
+                setMidiTracks(getVSQSequence());
+                super.writeMidiFile(vsq);
+        }
+
+        public Map<String, List<String>> decode(List<MidiData> md) throws IOException{
+                List<Byte> v = new ArrayList<Byte>();
+                for(int i = 0; i < md.size(); i++){
+                        MidiData m = md.get(i);
+                        if(m instanceof MidiMeta){
+                                byte b[] = ((MidiMeta)m).getData();
+                                if(b.length == 0){
+                                        continue;
+                                }
+                                String mmheader = new String(b);
+                                String[] ss = MMHEADER.split(mmheader, 2);
+                                if(ss.length > 1){
+                                        for(int k = mmheader.indexOf(ss[1]); k < b.length; k++){
+                                                if(b[k] != 0x00){
+                                                        v.add(b[k]);
+                                                }
+                                        }
+                                }
+                        }
+                }
+                byte b[] = new byte[v.size()];
+                for(int i = 0; i < v.size(); i++){
+                        b[i] = v.get(i);
+                }
+                String textevent = new String(b, WIN31J);
+                System.out.println(textevent);
+
+                Map<String, List<String>> sections = new LinkedHashMap<String, List<String>>();
+                BufferedReader br = new BufferedReader(new StringReader(textevent));
+                String bf;
+                String sn = "";
+                List<String> sv = new ArrayList<String>();
+                do{
+                        bf = br.readLine();
+                        if(bf == null || SECTIONLINE.matcher(bf).matches()){
+                                if(sn.length() > 0 && !sections.containsKey(sn)){
+                                        sections.put(sn.substring(1, sn.length() - 1), sv);
+                                }
+                                sn = bf;
+                                sv = new ArrayList<String>();
+                        }
+                        else if(bf.length() > 0){
+                                sv.add(bf);
+                        }
+                }while(bf != null);
+
+                return sections;
+        }
+
+        public List<MidiData> encode(List<String> trackSections){
+                String te = "";
+                for(int i = 0; i < trackSections.size(); i++){
+                        String vts = trackSections.get(i);
+                        te += vts + "\n";
+                }
+
+                List<MidiData> tme = new ArrayList<MidiData>();
+                byte b[] = te.getBytes(WIN31J);
+                for(int j = 0; j <= b.length / TEXTLENGTH; j++){
+                        int h = (int)StrictMath.ceil((double)Integer.toString(j).length() / 4.0);
+                        String mef = "DM:%0" + h * 4 + "d:";
+                        byte header[] = String.format(mef, j).getBytes(WIN31J);
+                        List<Byte> mbl = new ArrayList<Byte>();
+                        for(int k = 0; k < header.length; k++){
+                                mbl.add(header[k]);
+                        }
+                        for(int k = 0; k < TEXTLENGTH; k++){
+                                int bi = j * TEXTLENGTH + k;
+                                if(bi >= b.length){
+                                        break;
+                                }
+                                mbl.add(b[bi]);
+                        }
+                        byte mb[] = new byte[mbl.size()];
+                        for(int k = 0; k < mbl.size(); k++){
+                                mb[k] = mbl.get(k);
+                        }
+                        tme.add(new MidiMeta(1, mb));
+                }
+
+                return tme;
+        }
+
+        public void setVSQSequence(ArrayList<MidiTrack> t) throws IOException{
+                Map<String, List<String>> sections = decode(t.get(0).getMidiData(0L));
                 setMaster(new MasterSection(sections.get(MASTER)));
                 setMixer(new MixerSection(sections.get(MIXER)));
-                addTrack(new VSQTrack(t[1].get(0), getMixerSetting(0), sections));
-                for(int i = 2; i < t.length; i++){
-                        addTrack(new VSQTrack(t[i].get(0), getMixerSetting(i - 1), decode(t[i])));
-                }
-        }
-
-        public Sequence getVSQSequence() throws Exception{
-                Sequence sq = new Sequence(getDivisionType(), getResolution());
-                Track mt = sq.createTrack();
-                getConductor(mt);
+                addVSQTrack(new VSQTrack(getMixerSetting(0), sections));
+                for(int i = 1; i < t.size(); i++){
+                        addVSQTrack(new VSQTrack(getMixerSetting(i), decode(t.get(i).getMidiData(0L))));
+                }
+        }
+
+        public ArrayList<MidiTrack> getVSQSequence() throws InvalidBaseObjectException{
+                ArrayList<MidiTrack> t = new ArrayList<MidiTrack>();
 
                 List<List<String>> tsections = getVSQText();
-                for(int i = 0; i < getTrackSize(); i++){
-                        VSQTrack vt = getTrack(i);
-                        Track t = sq.createTrack();
-                        t.add(vt.getTrackNameME());
-                        List<MidiEvent> me = encode(tsections.get(i));
-                        for(int j = 0; j < me.size(); j++){
-                                t.add(me.get(j));
-                        }
-                }
-
-                return sq;
-        }
-
-        public List<List<String>> getVSQText() throws Exception{
-                if(!isReadied()){
-                        throw new Exception();
-                }
+                for(int i = 0; i < getVSQTrackSize(); i++){
+                        MidiTrack mt = new MidiTrack();
+                        mt.setMidiData(0L, encode(tsections.get(i)));
+                        t.add(mt);
+                }
+
+                return t;
+        }
+
+        public List<List<String>> getVSQText() throws InvalidBaseObjectException{
+                validate();
 
                 List<List<String>> tcommons = new ArrayList<List<String>>();
                 List<List<String>> ttimelines = new ArrayList<List<String>>();
-                for(int i = 0; i < getTrackSize(); i++){
-                        VSQTrack vt = getTrack(i);
+                for(int i = 0; i < getVSQTrackSize(); i++){
+                        VSQTrack vt = getVSQTrack(i);
                         tcommons.add(vt.getCommon().getSection());
                         ttimelines.add(vt.getTimeLine().getSectionFast());
@@ -128 +210 @@
                 vsqtext.add(sections);
 
-                for(int i = 1; i < getTrackSize(); i++){
+                for(int i = 1; i < getVSQTrackSize(); i++){
                         sections = new ArrayList<String>();
                         sections.add(setSectionBracket(COMMON));
@@ -164 +246 @@
         }
 
-        public int getTrackSize(){
+        public int getVSQTrackSize(){
                 return tracks.size();
         }
 
-        public void addTrack(VSQTrack vt){
+        public void addVSQTrack(VSQTrack vt){
                 if(vt == null || vt.isDeleted()){
                         return;
@@ -175 +257 @@
         }
 
-        public void addTrack(int index, VSQTrack vt){
+        public void addVSQTrack(int index, VSQTrack vt){
                 if(vt == null || vt.isDeleted()){
                         return;
                 }
-                if(index < getTrackSize()){
+                if(index < getVSQTrackSize()){
                         tracks.add(index, vt);
                 }
                 else{
-                        addTrack(vt);
-                }
-        }
-
-        public void setTrack(int index, VSQTrack vt){
+                        addVSQTrack(vt);
+                }
+        }
+
+        public void setVSQTrack(int index, VSQTrack vt){
                 if(vt == null || vt.isDeleted()){
-                        removeTrack(index);
-                        return;
-                }
-                if(index < getTrackSize()){
+                        removeVSQTrack(index);
+                        return;
+                }
+                if(index < getVSQTrackSize()){
                         tracks.set(index, vt);
                 }
                 else{
-                        addTrack(vt);
-                }
-        }
-
-        public VSQTrack getTrack(int index){
-                if(index < getTrackSize()){
+                        addVSQTrack(vt);
+                }
+        }
+
+        public VSQTrack getVSQTrack(int index){
+                if(index < getVSQTrackSize()){
                         return tracks.get(index);
                 }
@@ -209 +291 @@
         }
 
-        public VSQTrack removeTrack(int index){
-                if(index < getTrackSize()){
+        public VSQTrack removeVSQTrack(int index){
+                if(index < getVSQTrackSize()){
                         return tracks.remove(index);
                 }
@@ -223 +305 @@
                         sl.add("VsqFile=" + getVsqFileS());
                 }
-                if(hasFileType()){
-                        sl.add("FileType=" + getFileType());
-                }
-                if(hasDivisionType()){
-                        sl.add("DivisionType=" + getDivisionType());
-                }
-                if(hasResolution()){
-                        sl.add("Resolution=" + getResolution());
-                }
-                if(hasConductor()){
-                        sl.add("Conductor={" + getConductor().toString() + "}");
-                }
                 if(hasMaster()){
                         sl.add("Master={" + getMaster().toString() + "}");
@@ -241 +311 @@
                         sl.add("Mixer={" + getMixer().toString() + "}");
                 }
-                if(hasTracks()){
-                        StringBuffer sb = new StringBuffer();
-                        sb.append(getTrack(0).toString());
-                        for(int i = 1; i < getTrackSize(); i++){
-                                sb.append("," + getTrack(i).toString());
+                if(hasVSQTracks()){
+                        StringBuilder sb = new StringBuilder();
+                        sb.append(getVSQTrack(0).toString());
+                        for(int i = 1; i < getVSQTrackSize(); i++){
+                                sb.append("," + getVSQTrack(i).toString());
                         }
                         sl.add("Tracks=[" + sb.toString() + "]");
                 }
 
-                StringBuffer sb = new StringBuffer();
+                StringBuilder sb = new StringBuilder();
+                sb.append(super.toString());
+
                 sb.append("VSQFile={");
                 if(!sl.isEmpty()){
@@ -262 +334 @@
         }
 
-        public boolean isReadied(){
-                boolean ready = true;
-                ready &= hasFileType();
-                ready &= hasDivisionType();
-                ready &= hasResolution();
-                ready &= hasConductor() && getConductor().isReadied();
-                ready &= hasMaster() && getMaster().isReadied();
-                ready &= hasMixer() && getMixer().isReadied();
-                for(int i = 0; i < getTrackSize(); i++){
-                        ready &= getTrack(i).isReadied();
+        public boolean validate() throws InvalidBaseObjectException{
+                boolean ready = super.validate();
+                ready &= hasMaster() && getMaster().validate();
+                ready &= hasMixer() && getMixer().validate();
+                for(int i = 0; i < getVSQTrackSize(); i++){
+                        ready &= getVSQTrack(i).validate();
+                }
+                if(!ready){
+                        throw new InvalidBaseObjectException(this);
                 }
                 return ready;
         }
 
-        public int compareTo(ImmutableObject obj){
-                VSQFile vsqFile = (VSQFile)obj;
-                return compare(getVsqFile().getPath(), vsqFile.getVsqFile().getPath());
-        }
-
-        public VSQFile over(Object obj, boolean fill, boolean has){
+        public VSQFile over(BaseObject obj, boolean fill, boolean has){
+                super.over(obj, fill, has);
                 VSQFile vsqFile = ((VSQFile)obj).clone();
-                if(vsqFile.hasFileType() && (fill || has == hasFileType())){
-                        setFileType(vsqFile.getFileType());
-                }
-                if(vsqFile.hasDivisionType() && (fill || has == hasDivisionType())){
-                        setDivisionType(vsqFile.getDivisionType());
-                }
-                if(vsqFile.hasResolution() && (fill || has == hasResolution())){
-                        setResolution(vsqFile.getResolution());
-                }
-                if(vsqFile.hasConductor()){
-                        MidiTrack conductor = hasConductor() ? getConductor() : new MidiTrack();
-                        setConductor(conductor.over(vsqFile.getConductor(), fill, has));
-                }
                 if(vsqFile.hasMaster()){
                         MasterSection master = hasMaster() ? getMaster() : new MasterSection();
@@ -304 +358 @@
                         setMixer(mixer.over(vsqFile.getMixer(), fill, has));
                 }
-                for(int i = 0; i < vsqFile.getTracks().size(); i++){
-                        VSQTrack vt = getTrack(i);
-                        setTrack(i, vt.over(vsqFile.getTrack(i), fill, has));
-                }
-                if(vsqFile.hasVsqFile() && (fill || has == hasVsqFile())){
-                        setVsqFile(vsqFile.getVsqFile());
+                for(int i = 0; i < vsqFile.getVSQTracks().size(); i++){
+                        VSQTrack vt = getVSQTrack(i);
+                        setVSQTrack(i, vt.over(vsqFile.getVSQTrack(i), fill, has));
                 }
                 return this;
@@ -315 +366 @@
 
         public VSQFile setDefault(){
-                setFileType(1);
-                setDivisionType(0.0f);
-                setResolution(480);
-                setConductor(new MidiTrack());
+                super.setDefault();
                 setMaster(MasterSection.getDefault());
                 setMixer(MixerSection.getDefault());
-                deleteTracks();
-                addTrack(VSQTrack.getDefault());
-                deleteVsqFile();
+                deleteVSQTracks();
+                addVSQTrack(VSQTrack.getDefault());
                 return this;
         }
@@ -334 +381 @@
 
         public VSQFile delete(){
-                deleteFileType();
-                deleteDivisionType();
-                deleteResolution();
-                deleteConductor();
+                super.delete();
                 deleteMaster();
                 deleteMixer();
-                deleteTracks();
-                deleteVsqFile();
+                deleteVSQTracks();
                 return this;
         }
 
         public boolean isDeleted(){
-                boolean has = false;
-                has |= hasFileType();
-                has |= hasDivisionType();
-                has |= hasResolution();
-                has |= hasConductor();
+                boolean has = super.isDeleted();
                 has |= hasMaster();
                 has |= hasMixer();
-                has |= hasTracks();
-                has |= hasVsqFile();
+                has |= hasVSQTracks();
                 return !has;
         }
 
         public VSQFile(){
+                super();
                 delete();
         }
 
         public File getVsqFile(){
-                return vsqFile;
+                return getMidiFile();
         }
 
@@ -371 +410 @@
 
         public void setVsqFile(File vsqFile){
-                this.vsqFile = vsqFile;
+                setMidiFile(vsqFile);
         }
 
@@ -379 +418 @@
 
         public void deleteVsqFile(){
-                vsqFile = null;
+                deleteMidiFile();
         }
 
         public boolean hasVsqFile(){
-                return vsqFile != null;
-        }
-
-        public Integer getFileType(){
-                return fileType;
-        }
-
-        public void setFileType(Integer fileType){
-                this.fileType = fileType;
-        }
-
-        public void deleteFileType(){
-                fileType = null;
-        }
-
-        public boolean hasFileType(){
-                return fileType != null;
-        }
-
-        public Float getDivisionType(){
-                return divisionType;
-        }
-
-        public void setDivisionType(Float divisionType){
-                this.divisionType = divisionType;
-        }
-
-        public void deleteDivisionType(){
-                divisionType = null;
-        }
-
-        public boolean hasDivisionType(){
-                return divisionType != null;
-        }
-
-        public Integer getResolution(){
-                return resolution;
-        }
-
-        public void setResolution(Integer resolution){
-                this.resolution = resolution;
-        }
-
-        public void deleteResolution(){
-                resolution = null;
-        }
-
-        public boolean hasResolution(){
-                return resolution != null;
-        }
-
-        public MidiTrack getConductor(){
-                return conductor;
-        }
-
-        public void getConductor(Track t) throws Exception{
-                conductor.getTrack(t);
-        }
-
-        public void setConductor(MidiTrack conductor){
-                if(conductor == null || conductor.isDeleted()){
-                        deleteConductor();
-                        return;
-                }
-                this.conductor = conductor;
-        }
-
-        public void setConductor(Track t){
-                this.conductor = new MidiTrack(t);
-        }
-
-        public void deleteConductor(){
-                conductor = null;
-        }
-
-        public boolean hasConductor(){
-                return conductor != null;
+                return hasMidiFile();
         }
 
@@ -502 +465 @@
         }
 
-        public ArrayList<VSQTrack> getTracks(){
+        public ArrayList<VSQTrack> getVSQTracks(){
                 return tracks;
         }
 
-        public void setTracks(ArrayList<VSQTrack> tracks){
+        public void setVSQTracks(ArrayList<VSQTrack> tracks){
                 if(tracks == null){
-                        deleteTracks();
+                        deleteVSQTracks();
                         return;
                 }
@@ -514 +477 @@
         }
 
-        public void deleteTracks(){
-                setTracks(new ArrayList<VSQTrack>());
-        }
-
-        public boolean hasTracks(){
+        public void deleteVSQTracks(){
+                setVSQTracks(new ArrayList<VSQTrack>());
+        }
+
+        public boolean hasVSQTracks(){
                 return !tracks.isEmpty();
         }
@@ -526 +489 @@
         }
 
-        public static VSQFile load(String file) throws Exception{
-                return (VSQFile)ImmutableObject.load(file);
-        }
-
-        public static VSQFile load(File file) throws Exception{
-                return (VSQFile)ImmutableObject.load(file);
-        }
-
-        public void store(String file) throws Exception{
+        public static VSQFile load(String file) throws FileNotFoundException, IOException, ClassNotFoundException{
+                return (VSQFile)BaseObject.load(file);
+        }
+
+        public static VSQFile load(File file) throws FileNotFoundException, IOException, ClassNotFoundException{
+                return (VSQFile)BaseObject.load(file);
+        }
+
+        public void store(String file) throws FileNotFoundException, IOException{
                 super.store(file);
         }
 
-        public void store(File file) throws Exception{
+        public void store(File file) throws FileNotFoundException, IOException{
                 super.store(file);
         }
 
-        public static VSQFile unzip(String file) throws Exception{
-                return (VSQFile)ImmutableObject.unzip(file);
-        }
-
-        public static VSQFile unzip(File file) throws Exception{
-                return (VSQFile)ImmutableObject.unzip(file);
-        }
-
-        public void zip(String file) throws Exception{
+        public static VSQFile unzip(String file) throws IOException, ClassNotFoundException{
+                return (VSQFile)BaseObject.unzip(file);
+        }
+
+        public static VSQFile unzip(File file) throws IOException, ClassNotFoundException{
+                return (VSQFile)BaseObject.unzip(file);
+        }
+
+        public void zip(String file) throws IOException{
                 super.zip(file);
         }
 
-        public void zip(File file) throws Exception{
+        public void zip(File file) throws IOException{
                 super.zip(file);
         }