← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/tuxguitar/oneiric

« back to all changes in this revision

Viewing changes to src/org/herac/tuxguitar/io/tg/TGOutputStream.java

  • Committer: Bazaar Package Importer
  • Author(s): Philippe Coval
  • Date: 2007-02-04 01:41:23 UTC
  • Revision ID: james.westby@ubuntu.com-20070204014123-9pv7okph0iaiqkvw
Tags: upstream-0.9.1
Import upstream version 0.9.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/org/herac/tuxguitar/io/tg/TGOutputStream.java
 
1
/*
 
2
 * Created on 16-dic-2005
 
3
 *
 
4
 * TODO To change the template for this generated file go to
 
5
 * Window - Preferences - Java - Code Style - Code Templates
 
6
 */
 
7
package org.herac.tuxguitar.io.tg;
 
8
 
 
9
import java.io.DataOutputStream;
 
10
import java.io.File;
 
11
import java.io.FileNotFoundException;
 
12
import java.io.FileOutputStream;
 
13
import java.io.IOException;
 
14
import java.util.ArrayList;
 
15
import java.util.Iterator;
 
16
import java.util.List;
 
17
 
 
18
import org.herac.tuxguitar.song.models.Component;
 
19
import org.herac.tuxguitar.song.models.Duration;
 
20
import org.herac.tuxguitar.song.models.InstrumentString;
 
21
import org.herac.tuxguitar.song.models.Lyric;
 
22
import org.herac.tuxguitar.song.models.Marker;
 
23
import org.herac.tuxguitar.song.models.Measure;
 
24
import org.herac.tuxguitar.song.models.MeasureHeader;
 
25
import org.herac.tuxguitar.song.models.Note;
 
26
import org.herac.tuxguitar.song.models.NoteEffect;
 
27
import org.herac.tuxguitar.song.models.RGBColor;
 
28
import org.herac.tuxguitar.song.models.Silence;
 
29
import org.herac.tuxguitar.song.models.Song;
 
30
import org.herac.tuxguitar.song.models.SongChannel;
 
31
import org.herac.tuxguitar.song.models.SongTrack;
 
32
import org.herac.tuxguitar.song.models.Tempo;
 
33
import org.herac.tuxguitar.song.models.TimeSignature;
 
34
import org.herac.tuxguitar.song.models.Tupleto;
 
35
import org.herac.tuxguitar.song.models.VelocityValues;
 
36
import org.herac.tuxguitar.song.models.effects.BendEffect;
 
37
import org.herac.tuxguitar.song.models.effects.GraceEffect;
 
38
import org.herac.tuxguitar.song.models.effects.HarmonicEffect;
 
39
import org.herac.tuxguitar.song.models.effects.TremoloBarEffect;
 
40
import org.herac.tuxguitar.song.models.effects.TremoloPickingEffect;
 
41
import org.herac.tuxguitar.song.models.effects.TrillEffect;
 
42
 
 
43
/**
 
44
 * @author julian
 
45
 *
 
46
 * TODO To change the template for this generated type comment go to
 
47
 * Window - Preferences - Java - Code Style - Code Templates
 
48
 */
 
49
public class TGOutputStream extends TGStream{    
 
50
    private DataOutputStream dataOutputStream;       
 
51
    
 
52
    public TGOutputStream(FileOutputStream file) throws FileNotFoundException {
 
53
        this.dataOutputStream = new DataOutputStream(file);
 
54
    }
 
55
 
 
56
    public TGOutputStream(String fileName) throws FileNotFoundException {
 
57
        this(new FileOutputStream(new File(fileName)));
 
58
    }
 
59
    
 
60
    public void write(Song song){        
 
61
        try {
 
62
            this.writeVersion();
 
63
            this.writeSong(song);
 
64
            this.dataOutputStream.flush();
 
65
            this.dataOutputStream.close();
 
66
        } catch (IOException e) {            
 
67
            e.printStackTrace();
 
68
        }
 
69
    }
 
70
 
 
71
    private void writeVersion(){
 
72
        writeString(TG_VERSION);
 
73
    }
 
74
    
 
75
    
 
76
    private void writeSong(Song song){
 
77
        //escribo el nombre
 
78
        writeString(song.getName());
 
79
        
 
80
        //escribo el interprete
 
81
        writeString(song.getInterpret());
 
82
        
 
83
        //escribo el album
 
84
        writeString(song.getAlbum());
 
85
 
 
86
        //escribo el autor
 
87
        writeString(song.getAuthor());        
 
88
        
 
89
        //escribo la cantidad de measure headers 
 
90
        writeShort((short)song.getMeasureHeaders().size());
 
91
        
 
92
        //escribo las pistas
 
93
        MeasureHeader lastHeader = null;
 
94
        for(int i = 0;i < song.getMeasureHeaders().size();i++){
 
95
                MeasureHeader header = (MeasureHeader)song.getMeasureHeaders().get(i);
 
96
            writeMeasureHeader(header,lastHeader);
 
97
            
 
98
            lastHeader = header;
 
99
        }        
 
100
        
 
101
        //escribo la cantidad de pistas 
 
102
        writeByte(song.getTracks().size());
 
103
        
 
104
        //escribo las pistas
 
105
        for(int i = 0;i < song.getTracks().size();i++){
 
106
            SongTrack track = (SongTrack)song.getTracks().get(i);
 
107
            writeTrack(track);
 
108
        }
 
109
        
 
110
    }
 
111
    
 
112
    private void writeTrack(SongTrack track){  
 
113
        //header
 
114
        int header = 0;
 
115
        if(!track.getLyrics().isEmpty()){
 
116
                header |= TRACK_LYRICS;
 
117
        }
 
118
        writeHeader(header);            
 
119
        
 
120
        //escribo el nombre
 
121
        writeString(track.getName());
 
122
        
 
123
        //escribo el canal
 
124
        writeChannel(track.getChannel());
 
125
 
 
126
        //escribo los compases
 
127
        Measure lastMeasure = null;
 
128
        Iterator measureIt  = track.getMeasures().iterator();
 
129
        while(measureIt.hasNext()){
 
130
            Measure measure = (Measure)measureIt.next();
 
131
            writeMeasure(measure,lastMeasure);
 
132
            lastMeasure = measure;
 
133
        }                       
 
134
        
 
135
        //escribo la cantidad de cuerdas 
 
136
        writeByte(track.getStrings().size());        
 
137
        
 
138
        //escribo las cuerdas
 
139
        Iterator stringIt  = track.getStrings().iterator();
 
140
        while(stringIt.hasNext()){
 
141
            InstrumentString string = (InstrumentString)stringIt.next();
 
142
            writeInstrumentString(string);
 
143
        }       
 
144
        
 
145
        //escribo el offset
 
146
        writeByte(track.getOffset() - SongTrack.MIN_OFFSET);
 
147
        
 
148
        //escribo el color
 
149
        writeRGBColor(track.getColor());
 
150
        
 
151
        //escribo el lyrics
 
152
        if(((header & TRACK_LYRICS) != 0)){
 
153
                writeLyrics(track.getLyrics());
 
154
        }
 
155
    }
 
156
    
 
157
    
 
158
 
 
159
    private void writeMeasureHeader(MeasureHeader measureheader,MeasureHeader lastMeasureHeader){
 
160
        int header = 0;
 
161
        if(lastMeasureHeader == null){
 
162
                header |= MEASURE_HEADER_TIMESIGNATURE;
 
163
                header |= MEASURE_HEADER_TEMPO;
 
164
                if(measureheader.getTripletFeel() != MeasureHeader.TRIPLET_FEEL_NONE){ 
 
165
                        header |= MEASURE_HEADER_TRIPLET_FEEL;                          
 
166
                }
 
167
        }else{
 
168
                //Time Signature
 
169
                int numerator = measureheader.getTimeSignature().getNumerator();
 
170
                int value = measureheader.getTimeSignature().getDenominator().getValue();
 
171
                int prevNumerator = lastMeasureHeader.getTimeSignature().getNumerator();
 
172
                int prevValue = lastMeasureHeader.getTimeSignature().getDenominator().getValue();            
 
173
                if(numerator != prevNumerator || value != prevValue){
 
174
                        header |= MEASURE_HEADER_TIMESIGNATURE;
 
175
                }               
 
176
                //Tempo
 
177
                if(measureheader.getTempo().getValue() != lastMeasureHeader.getTempo().getValue()){
 
178
                        header |= MEASURE_HEADER_TEMPO;
 
179
                }
 
180
                //Triplet Feel
 
181
                if(measureheader.getTripletFeel() != lastMeasureHeader.getTripletFeel()){
 
182
                        header |= MEASURE_HEADER_TRIPLET_FEEL;
 
183
                }
 
184
        }
 
185
        header = (measureheader.isRepeatStart())?header |= MEASURE_HEADER_OPEN_REPEAT:header;
 
186
        header = (measureheader.getNumberOfRepetitions() > 0)?header |= MEASURE_HEADER_CLOSE_REPEAT:header;
 
187
        header = (measureheader.hasMarker())?header |= MEASURE_HEADER_MARKER:header;            
 
188
        
 
189
        writeHeader(header);
 
190
 
 
191
        //escribo el timeSignature      
 
192
        if(((header & MEASURE_HEADER_TIMESIGNATURE) != 0)){
 
193
                writeTimeSignature(measureheader.getTimeSignature());
 
194
        }
 
195
        
 
196
        //escribo el tempo
 
197
        if(((header & MEASURE_HEADER_TEMPO) != 0)){
 
198
                writeTempo(measureheader.getTempo());                         
 
199
        }
 
200
        
 
201
        //escribo el numero de repeticiones
 
202
        if(((header & MEASURE_HEADER_CLOSE_REPEAT) != 0)){
 
203
                writeShort((short)measureheader.getNumberOfRepetitions());
 
204
        }
 
205
                
 
206
        //escribo el marker
 
207
        if(((header & MEASURE_HEADER_MARKER) != 0)){
 
208
                writeMarker(measureheader.getMarker());
 
209
        }
 
210
        
 
211
        //escribo el triplet feel
 
212
        if(((header & MEASURE_HEADER_TRIPLET_FEEL) != 0)){
 
213
                writeByte(measureheader.getTripletFeel());
 
214
        }    
 
215
    }        
 
216
    
 
217
    
 
218
    private void writeMeasure(Measure measure,Measure lastMeasure){      
 
219
        int header = 0;         
 
220
        if(lastMeasure == null){
 
221
                header |= MEASURE_CLEF;
 
222
                header |= MEASURE_KEYSIGNATURE;
 
223
        }else{
 
224
                //Clef
 
225
                if(measure.getClef() != lastMeasure.getClef()){
 
226
                        header |= MEASURE_CLEF;
 
227
                }               
 
228
                //KeySignature
 
229
                if(measure.getKeySignature() != lastMeasure.getKeySignature()){
 
230
                        header |= MEASURE_KEYSIGNATURE;
 
231
                }                                       
 
232
        }               
 
233
        writeHeader(header);
 
234
        
 
235
 
 
236
        List components = getMeasureComponents(measure);
 
237
                //escribo la cantidad de notas 
 
238
                writeShort((short)components.size());        
 
239
    
 
240
                //escribo las cuerdas
 
241
                Component lastComponent = null;
 
242
                Iterator it  = components.iterator();
 
243
                while(it.hasNext()){
 
244
                        Component component = (Component)it.next();
 
245
                        writeComponent(component,lastComponent);
 
246
                        lastComponent = component;
 
247
                }               
 
248
 
 
249
        //escribo la clave
 
250
        if(((header & MEASURE_CLEF) != 0)){
 
251
                writeByte(measure.getClef());
 
252
        }
 
253
        
 
254
        //escribo el key signature
 
255
        if(((header & MEASURE_KEYSIGNATURE) != 0)){
 
256
                writeByte(measure.getKeySignature());
 
257
        }
 
258
    }    
 
259
 
 
260
    private void writeChannel(SongChannel channel){                
 
261
        int header = 0;         
 
262
        header = (channel.isSolo())?header |= CHANNEL_SOLO:header;
 
263
        header = (channel.isMute())?header |= CHANNEL_MUTE:header;
 
264
        writeHeader(header);
 
265
        
 
266
        //escribo el canal        
 
267
        writeByte(channel.getChannel());
 
268
 
 
269
        //escribo el canal de efectos        
 
270
        writeByte(channel.getEffectChannel());
 
271
        
 
272
        //escribo el instrumento        
 
273
        writeByte(channel.getInstrument());
 
274
        
 
275
        //escribo el volumen        
 
276
        writeByte(channel.getVolume());
 
277
        
 
278
        //escribo el balance        
 
279
        writeByte(channel.getBalance());
 
280
        
 
281
        //escribo el chorus        
 
282
        writeByte(channel.getChorus());
 
283
        
 
284
        //escribo el reverb        
 
285
        writeByte(channel.getReverb());
 
286
        
 
287
        //escribo el phaser        
 
288
        writeByte(channel.getPhaser());
 
289
        
 
290
        //escribo el tremolo        
 
291
        writeByte(channel.getTremolo());        
 
292
    }      
 
293
 
 
294
    private void writeComponent(Component component,Component lastComponent){        
 
295
        int header = 0;
 
296
        if(component instanceof Note){
 
297
                Note note = (Note)component;                    
 
298
                header |= COMPONENT_NOTE;
 
299
                header = (note.isTiedNote())?header |= COMPONENT_TIEDNOTE:header;
 
300
                header = ( !(lastComponent instanceof Note) && note.getVelocity() != VelocityValues.DEFAULT  )?header |= COMPONENT_VELOCITY:header;
 
301
                header = ((lastComponent instanceof Note) && (note.getVelocity() != ((Note)lastComponent).getVelocity() ) )?header |= COMPONENT_VELOCITY:header;                
 
302
                header = (note.getEffect().hasAnyEffect())?header |= COMPONENT_EFFECT:header;                           
 
303
        }else if(component instanceof Silence){
 
304
                header |= COMPONENT_SILENCE;
 
305
        }
 
306
        header = (lastComponent == null || component.getStart() != lastComponent.getStart())?header |= COMPONENT_NEXT_BEAT:header;
 
307
        header = (lastComponent == null || !component.getDuration().isEqual(lastComponent.getDuration()))?header |= COMPONENT_NEXT_DURATION:header;
 
308
        
 
309
        writeHeader(header);
 
310
 
 
311
        //escribo la duracion
 
312
        if(((header & COMPONENT_NEXT_DURATION) != 0)){
 
313
                writeDuration(component.getDuration());
 
314
        }
 
315
        if(((header & COMPONENT_NOTE) != 0)){
 
316
                Note note = (Note)component;  
 
317
                
 
318
                //escribo el valor
 
319
                writeByte(note.getValue());
 
320
        
 
321
                //escribo la cuerda
 
322
                writeByte(note.getString());
 
323
        
 
324
                //escribo el velocity
 
325
                if(((header & COMPONENT_VELOCITY) != 0)){
 
326
                        writeByte(note.getVelocity());
 
327
                }    
 
328
                
 
329
                //escribo los efectos
 
330
                if(((header & COMPONENT_EFFECT) != 0)){
 
331
                        writeNoteEffect(note.getEffect());
 
332
                }     
 
333
                
 
334
        }
 
335
    }    
 
336
    
 
337
    
 
338
    private void writeInstrumentString(InstrumentString string){        
 
339
        //escribo el valor
 
340
        writeByte(string.getValue());                          
 
341
    }
 
342
    
 
343
    
 
344
    private void writeTempo(Tempo tempo){
 
345
        //escribo el valor
 
346
        writeShort((short)tempo.getValue());
 
347
    }    
 
348
    
 
349
    
 
350
    private void writeTimeSignature(TimeSignature timeSignature){
 
351
        //escribo el numerador
 
352
        writeByte(timeSignature.getNumerator());
 
353
        
 
354
        //escribo el denominador
 
355
        writeDuration(timeSignature.getDenominator());
 
356
    }
 
357
    
 
358
    private void writeDuration(Duration duration){        
 
359
        int header = 0;
 
360
        header = (duration.isDotted())?header |= DURATION_DOTTED:header;        
 
361
        header = (duration.isDoubleDotted())?header |= DURATION_DOUBLE_DOTTED:header;        
 
362
        header = (!duration.getTupleto().isEqual(Duration.NO_TUPLETO))?header |= DURATION_TUPLETO:header;
 
363
        writeHeader(header);
 
364
        
 
365
        //escribo el valor
 
366
        writeByte(duration.getValue());
 
367
        
 
368
        //escribo el tupleto
 
369
        if(((header & DURATION_TUPLETO) != 0)){
 
370
                writeTupleto(duration.getTupleto());
 
371
        }
 
372
    }    
 
373
    
 
374
    private void writeTupleto(Tupleto tupleto){                
 
375
        //escribo los enters
 
376
        writeByte(tupleto.getEnters());
 
377
        
 
378
        //escribo los tiempos
 
379
        writeByte(tupleto.getTimes());
 
380
    }       
 
381
    
 
382
    
 
383
    private void writeNoteEffect(NoteEffect effect){
 
384
        int header = 0;
 
385
                
 
386
        header = (effect.isBend())?header |= EFFECT_BEND:header;
 
387
        header = (effect.isTremoloBar())?header |= EFFECT_TREMOLO_BAR:header;
 
388
        header = (effect.isHarmonic())?header |= EFFECT_HARMONIC:header;
 
389
        header = (effect.isGrace())?header |= EFFECT_GRACE:header;
 
390
        header = (effect.isTrill())?header |= EFFECT_TRILL:header;
 
391
        header = (effect.isTremoloPicking())?header |= EFFECT_TREMOLO_PICKING:header;
 
392
        header = (effect.isVibrato())?header |= EFFECT_VIBRATO:header;
 
393
        header = (effect.isDeadNote())?header |= EFFECT_DEAD:header;
 
394
        header = (effect.isSlide())?header |= EFFECT_SLIDE:header;
 
395
        header = (effect.isHammer())?header |= EFFECT_HAMMER:header;
 
396
        header = (effect.isGhostNote())?header |= EFFECT_GHOST:header;
 
397
        header = (effect.isAccentuatedNote())?header |= EFFECT_ACCENTUATED:header;
 
398
        header = (effect.isHeavyAccentuatedNote())?header |= EFFECT_HEAVY_ACCENTUATED:header;
 
399
        header = (effect.isPalmMute())?header |= EFFECT_PALM_MUTE:header;
 
400
        header = (effect.isStaccato())?header |= EFFECT_STACCATO:header;
 
401
        header = (effect.isTapping())?header |= EFFECT_TAPPING:header;
 
402
        header = (effect.isSlapping())?header |= EFFECT_SLAPPING:header;
 
403
        header = (effect.isPopping())?header |= EFFECT_POPPING:header;
 
404
        header = (effect.isFadeIn())?header |= EFFECT_FADE_IN:header;
 
405
 
 
406
        writeHeader(header,3);
 
407
        
 
408
        //escribo el bend
 
409
        if(((header & EFFECT_BEND) != 0)){
 
410
            writeBendEffect(effect.getBend());
 
411
        }
 
412
        
 
413
        //leo el tremolo bar
 
414
        if(((header & EFFECT_TREMOLO_BAR) != 0)){
 
415
            writeTremoloBarEffect(effect.getTremoloBar());
 
416
        }
 
417
        
 
418
        //leo el harmonic
 
419
        if(((header & EFFECT_HARMONIC) != 0)){
 
420
            writeHarmonicEffect(effect.getHarmonic());
 
421
        }
 
422
        
 
423
        //leo el grace
 
424
        if(((header & EFFECT_GRACE) != 0)){
 
425
            writeGraceEffect(effect.getGrace());
 
426
        }
 
427
        
 
428
        //leo el trill
 
429
        if(((header & EFFECT_TRILL) != 0)){
 
430
            writeTrillEffect(effect.getTrill());
 
431
        }
 
432
        
 
433
        //leo el tremolo picking
 
434
        if(((header & EFFECT_TREMOLO_PICKING) != 0)){
 
435
            writeTremoloPickingEffect(effect.getTremoloPicking());
 
436
        }       
 
437
    }    
 
438
    
 
439
    private void writeBendEffect(BendEffect effect){        
 
440
        //escribo la cantidad de puntos
 
441
        writeByte(effect.getPoints().size());
 
442
        
 
443
        Iterator it = effect.getPoints().iterator();
 
444
        while(it.hasNext()){
 
445
            BendEffect.BendPoint point = (BendEffect.BendPoint)it.next();
 
446
            
 
447
            //escribo la posicion
 
448
            writeByte(point.getPosition());
 
449
            
 
450
            //escribo el valor
 
451
            writeByte(point.getValue());            
 
452
        }        
 
453
    }
 
454
    
 
455
    private void writeTremoloBarEffect(TremoloBarEffect effect){        
 
456
        //escribo la cantidad de puntos
 
457
        writeByte(effect.getPoints().size());
 
458
        
 
459
        Iterator it = effect.getPoints().iterator();
 
460
        while(it.hasNext()){
 
461
                TremoloBarEffect.TremoloBarPoint point = (TremoloBarEffect.TremoloBarPoint)it.next();
 
462
            
 
463
            //escribo la posicion
 
464
            writeByte(point.getPosition());
 
465
            
 
466
            //escribo el valor
 
467
            writeByte( (point.getValue() + TremoloBarEffect.MAX_VALUE_LENGTH) );            
 
468
        }        
 
469
    }    
 
470
    
 
471
    private void writeHarmonicEffect(HarmonicEffect effect){            
 
472
        //excribo el tipo
 
473
        writeByte(effect.getType());
 
474
        
 
475
        //excribo la data
 
476
        if(effect.getType() == HarmonicEffect.TYPE_ARTIFICIAL){                 
 
477
                writeByte(effect.getData() - HarmonicEffect.MIN_ARTIFICIAL_OFFSET);
 
478
        }else if(effect.getType() == HarmonicEffect.TYPE_TAPPED){
 
479
                writeByte(effect.getData());
 
480
        }
 
481
    }      
 
482
    
 
483
    private void writeGraceEffect(GraceEffect effect){          
 
484
        int header = 0;         
 
485
        header = (effect.isDead())?header |= GRACE_FLAG_DEAD:header;
 
486
        header = (effect.isOnBeat())?header |= GRACE_FLAG_ON_BEAT:header;       
 
487
        
 
488
        //excribo el header
 
489
        writeHeader(header);
 
490
        
 
491
        //excribo el fret
 
492
        writeByte(effect.getFret());
 
493
        
 
494
        //excribo la duracion
 
495
        writeByte(effect.getDuration());
 
496
        
 
497
        //excribo el velocity
 
498
        writeByte(effect.getDynamic());
 
499
        
 
500
        //excribo la transicion
 
501
        writeByte(effect.getTransition());      
 
502
    }     
 
503
    
 
504
    private void writeTremoloPickingEffect(TremoloPickingEffect effect){        
 
505
        //excribo la duracion
 
506
        writeByte(effect.getDuration().getValue());
 
507
    }       
 
508
 
 
509
    private void writeTrillEffect(TrillEffect effect){          
 
510
        //excribo el fret
 
511
        writeByte(effect.getFret());
 
512
        
 
513
        //excribo la duracion
 
514
        writeByte(effect.getDuration().getValue());
 
515
    }           
 
516
    
 
517
    
 
518
    private void writeMarker(Marker marker){
 
519
        //escribo el titulo
 
520
        writeString(marker.getTitle());
 
521
        
 
522
        //escribo el color
 
523
        writeRGBColor(marker.getColor());        
 
524
    }    
 
525
    
 
526
    private void writeRGBColor(RGBColor color){                
 
527
        //escribo el RGB
 
528
        writeShort((short)color.getR());
 
529
        writeShort((short)color.getG());
 
530
        writeShort((short)color.getB());
 
531
    }   
 
532
    
 
533
    private void writeLyrics(Lyric lyrics){
 
534
        //escribo el compas de comienzo
 
535
        writeShort((short)lyrics.getFrom());
 
536
        
 
537
        //escribo el texto
 
538
        writeString(lyrics.getLyrics());
 
539
    }
 
540
    
 
541
    
 
542
    private List getMeasureComponents(Measure measure){
 
543
        List components = new ArrayList();
 
544
        components.addAll(measure.getNotes());
 
545
        components.addAll(measure.getSilences());       
 
546
        
 
547
        for(int i = 0;i < components.size();i++){
 
548
            Component minComponent = null;
 
549
            for(int j = i;j < components.size();j++){
 
550
                Component component = (Component)components.get(j);
 
551
                if(minComponent == null || component.getStart() < minComponent.getStart()){
 
552
                    minComponent = component;
 
553
                }
 
554
            }
 
555
            components.remove(minComponent);
 
556
            components.add(i,minComponent);
 
557
        }
 
558
        return components;
 
559
    }    
 
560
    
 
561
    public void writeByte(int v){
 
562
        try {
 
563
            this.dataOutputStream.write(v);            
 
564
        } catch (IOException e) {            
 
565
            e.printStackTrace();
 
566
        }                
 
567
    }      
 
568
    
 
569
    private void writeString(String v){
 
570
        try {           
 
571
            this.dataOutputStream.write(v.length());
 
572
            this.dataOutputStream.writeChars(v);
 
573
        } catch (IOException e) {            
 
574
            e.printStackTrace();
 
575
        }                
 
576
    }
 
577
    
 
578
    public void writeHeader(int v){
 
579
        try {
 
580
            this.dataOutputStream.write(v);            
 
581
        } catch (IOException e) {            
 
582
            e.printStackTrace();
 
583
        }                
 
584
    }    
 
585
 
 
586
    public void writeHeader(int v,int bCount){
 
587
        for(int i = bCount; i > 0; i --){       
 
588
                writeHeader( (v >>> ( (8 * i) - 8 ) )  &  0xFF);
 
589
        }
 
590
    }    
 
591
    
 
592
    
 
593
    public void writeShort(short v){
 
594
        try {           
 
595
            this.dataOutputStream.writeShort(v);              
 
596
        } catch (IOException e) {            
 
597
            e.printStackTrace();
 
598
        } 
 
599
    }    
 
600
 
 
601
}