1 /*
2  * @(#)AudioFormat.java - parse Audioheaders, basic class
3  *
4  * Copyright (c) 2003-2008 by dvb.matt, All Rights Reserved.
5  *
6  * This file is part of ProjectX, a free Java based demux utility.
7  * By the authors, ProjectX is intended for educational purposes only,
8  * as a non-commercial test project.
9  *
10  * The part of audio parsing was derived from the MPEG/Audio
11  * Software Simulation Group's audio codec and ATSC A/52 in a special modified manner.
12  *
13  *
14  * This program is free software; you can redistribute it and/or modify
15  * it under the terms of the GNU General Public License as published by
16  * the Free Software Foundation; either version 2 of the License, or
17  * (at your option) any later version.
18  *
19  * This program is distributed in the hope that it will be useful,
20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22  * GNU General Public License for more details.
23  *
24  * You should have received a copy of the GNU General Public License
25  * along with this program; if not, write to the Free Software
26  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
27  *
28  */
29 
30 package net.sourceforge.dvb.projectx.audio;
31 
32 import java.io.RandomAccessFile;
33 import java.io.IOException;
34 
35 import net.sourceforge.dvb.projectx.parser.CommonParsing;
36 import net.sourceforge.dvb.projectx.common.Common;
37 
38 
39 public class AudioFormat extends Object {
40 
41 	private AudioFormat impl = null;
42 
43 	/**
44 	 *
45 	 */
AudioFormat(int type)46 	public AudioFormat(int type)
47 	{
48 		setNewType(type);
49 	}
50 
51 	/**
52 	 *
53 	 */
AudioFormat(byte[] frame)54 	public AudioFormat(byte[] frame)
55 	{
56 		//unused, meant for autodetection
57 	}
58 
59 	/**
60 	 *
61 	 */
AudioFormat()62 	public AudioFormat()
63 	{
64 		init();
65 	}
66 
67 	/**
68 	 *
69 	 */
setNewType(int type)70 	public void setNewType(int type)
71 	{
72 		switch (type)
73 		{
74 		case CommonParsing.DTS_AUDIO:
75 			impl = new AudioFormatDTS();
76 			break;
77 
78 		case CommonParsing.AC3_AUDIO:
79 			impl = new AudioFormatAC3();
80 			break;
81 
82 		case CommonParsing.LPCM_AUDIO:
83 			impl = new AudioFormatLPCM();
84 			break;
85 
86 		case CommonParsing.WAV_AUDIO:
87 			impl = new AudioFormatWAV();
88 			break;
89 
90 		case CommonParsing.MPEG_AUDIO:
91 			impl = new AudioFormatMPA();
92 			break;
93 
94 		case CommonParsing.AAC_AUDIO:
95 			impl = new AudioFormatAAC();//
96 			break;
97 		}
98 	}
99 
100 	private boolean INTEL;
101 
102 	private int ID;
103 	private int Layer;
104 	private int Protection_bit;
105 	private int Private_bit;
106 	private int Bitrate;
107 	private int Sampling_frequency;
108 	private int Padding_bit;
109 	private int Mode;
110 	private int Mode_extension;
111 	private int Copyright;
112 	private int Original;
113 	private int Channel;
114 	private int Emphasis;
115 	private int Size;
116 	private int Size_base;
117 	private double Time_length;
118 
119 	private int nID;
120 	private int nLayer;
121 	private int nProtection_bit;
122 	private int nPrivate_bit;
123 	private int nBitrate;
124 	private int nSampling_frequency;
125 	private int nPadding_bit;
126 	private int nMode;
127 	private int nMode_extension;
128 	private int nCopyright;
129 	private int nOriginal;
130 	private int nChannel;
131 	private int nEmphasis;
132 	private int nSize;
133 	private int nSize_base;
134 	private double nTime_length;
135 
136 	private int lID;
137 	private int lLayer;
138 	private int lProtection_bit;
139 	private int lPrivate_bit;
140 	private int lBitrate;
141 	private int lSampling_frequency;
142 	private int lPadding_bit;
143 	private int lMode;
144 	private int lMode_extension;
145 	private int lCopyright;
146 	private int lOriginal;
147 	private int lChannel;
148 	private int lEmphasis;
149 	private int lSize;
150 	private int lSize_base;
151 	private double lTime_length;
152 
153 	/**
154 	 *
155 	 */
init()156 	public void init()
157 	{
158 		setINTEL(false);
159 
160 		setID(0);
161 		setLayer(0);
162 		setProtectionBit(0);
163 		setPrivateBit(0);
164 		setBitrate(0);
165 		setSamplingFrequency(0);
166 		setPaddingBit(0);
167 		setPrivateBit(0);
168 		setMode(0);
169 		setModeExtension(0);
170 		setCopyright(0);
171 		setOriginal(0);
172 		setChannel(0);
173 		setEmphasis(0);
174 		setSize(0);
175 		setSizeBase(0);
176 		setFrameTimeLength(0.0);
177 	}
178 
179 
180 	/**
181 	 *
182 	 */
isINTEL()183 	public boolean isINTEL()
184 	{
185 		return (impl == null ? INTEL : impl.isINTEL());
186 	}
187 
188 	/**
189 	 *
190 	 */
setINTEL(boolean b)191 	public void setINTEL(boolean b)
192 	{
193 		if (impl != null)
194 			impl.setINTEL(b);
195 
196 		INTEL = b;
197 	}
198 
199 	/**
200 	 *
201 	 */
getID()202 	public int getID()
203 	{
204 		return (impl == null ? ID : impl.getID());
205 	}
206 
207 	/**
208 	 *
209 	 */
setID(int val)210 	public void setID(int val)
211 	{
212 		if (impl != null)
213 			impl.setID(val);
214 
215 		ID = val;
216 	}
217 
218 	/**
219 	 *
220 	 */
getLayer()221 	public int getLayer()
222 	{
223 		return (impl == null ? Layer : impl.getLayer());
224 	}
225 
226 	/**
227 	 *
228 	 */
setLayer(int val)229 	public void setLayer(int val)
230 	{
231 		if (impl != null)
232 			impl.setLayer(val);
233 
234 		Layer = val;
235 	}
236 
237 	/**
238 	 *
239 	 */
getBitrate()240 	public int getBitrate()
241 	{
242 		return (impl == null ? Bitrate : impl.getBitrate());
243 	}
244 
245 	/**
246 	 *
247 	 */
setBitrate(int val)248 	public void setBitrate(int val)
249 	{
250 		if (impl != null)
251 			impl.setBitrate(val);
252 
253 		Bitrate = val;
254 	}
255 
256 	/**
257 	 *
258 	 */
getSamplingFrequency()259 	public int getSamplingFrequency()
260 	{
261 		return (impl == null ? Sampling_frequency : impl.getSamplingFrequency());
262 	}
263 
264 	/**
265 	 *
266 	 */
setSamplingFrequency(int val)267 	public void setSamplingFrequency(int val)
268 	{
269 		if (impl != null)
270 			impl.setSamplingFrequency(val);
271 
272 		Sampling_frequency = val;
273 	}
274 
275 	/**
276 	 *
277 	 */
getMode()278 	public int getMode()
279 	{
280 		return (impl == null ? Mode : impl.getMode());
281 	}
282 
283 	/**
284 	 *
285 	 */
setMode(int val)286 	public void setMode(int val)
287 	{
288 		if (impl != null)
289 			impl.setMode(val);
290 
291 		Mode = val;
292 	}
293 
294 	/**
295 	 *
296 	 */
getModeExtension()297 	public int getModeExtension()
298 	{
299 		return (impl == null ? Mode_extension : impl.getModeExtension());
300 	}
301 
302 	/**
303 	 *
304 	 */
setModeExtension(int val)305 	public void setModeExtension(int val)
306 	{
307 		if (impl != null)
308 			impl.setModeExtension(val);
309 
310 		Mode_extension = val;
311 	}
312 
313 	/**
314 	 *
315 	 */
getEmphasis()316 	public int getEmphasis()
317 	{
318 		return (impl == null ? Emphasis : impl.getEmphasis());
319 	}
320 
321 	/**
322 	 *
323 	 */
setEmphasis(int val)324 	public void setEmphasis(int val)
325 	{
326 		if (impl != null)
327 			impl.setEmphasis(val);
328 
329 		Emphasis = val;
330 	}
331 
332 	/**
333 	 *
334 	 */
getSize()335 	public int getSize()
336 	{
337 		return (impl == null ? Size : impl.getSize());
338 	}
339 
340 	/**
341 	 *
342 	 */
setSize(int val)343 	public void setSize(int val)
344 	{
345 		if (impl != null)
346 			impl.setSize(val);
347 
348 		Size = val;
349 	}
350 
351 	/**
352 	 *
353 	 */
getSizeBase()354 	public int getSizeBase()
355 	{
356 		return (impl == null ? Size_base : impl.getSizeBase());
357 	}
358 
359 	/**
360 	 *
361 	 */
setSizeBase(int val)362 	public void setSizeBase(int val)
363 	{
364 		if (impl != null)
365 			setSizeBase(val);
366 
367 		Size_base = val;
368 	}
369 
370 	/**
371 	 *
372 	 */
getChannel()373 	public int getChannel()
374 	{
375 		return (impl == null ? Channel : impl.getChannel());
376 	}
377 
378 	/**
379 	 *
380 	 */
setChannel(int val)381 	public void setChannel(int val)
382 	{
383 		if (impl != null)
384 			impl.setChannel(val);
385 
386 		Channel = val;
387 	}
388 
389 	/**
390 	 *
391 	 */
getPaddingBit()392 	public int getPaddingBit()
393 	{
394 		return (impl == null ? Padding_bit : impl.getPaddingBit());
395 	}
396 
397 	/**
398 	 *
399 	 */
setPaddingBit(int val)400 	public void setPaddingBit(int val)
401 	{
402 		if (impl != null)
403 			impl.setPaddingBit(val);
404 
405 		Padding_bit = val;
406 	}
407 
408 	/**
409 	 *
410 	 */
getPrivateBit()411 	public int getPrivateBit()
412 	{
413 		return (impl == null ? Private_bit : impl.getPrivateBit());
414 	}
415 
416 	/**
417 	 *
418 	 */
setPrivateBit(int val)419 	public void setPrivateBit(int val)
420 	{
421 		if (impl != null)
422 			impl.setPrivateBit(val);
423 
424 		Private_bit = val;
425 	}
426 
427 	/**
428 	 *
429 	 */
getOriginal()430 	public int getOriginal()
431 	{
432 		return (impl == null ? Original : impl.getOriginal());
433 	}
434 
435 	/**
436 	 *
437 	 */
setOriginal(int val)438 	public void setOriginal(int val)
439 	{
440 		if (impl != null)
441 			impl.setOriginal(val);
442 
443 		Original = val;
444 	}
445 
446 	/**
447 	 *
448 	 */
getCopyright()449 	public int getCopyright()
450 	{
451 		return (impl == null ? Copyright : impl.getCopyright());
452 	}
453 
454 	/**
455 	 *
456 	 */
setCopyright(int val)457 	public void setCopyright(int val)
458 	{
459 		if (impl != null)
460 			impl.setCopyright(val);
461 
462 		Copyright = val;
463 	}
464 
465 	/**
466 	 *
467 	 */
getProtectionBit()468 	public int getProtectionBit()
469 	{
470 		return (impl == null ? Protection_bit : impl.getProtectionBit());
471 	}
472 
473 	/**
474 	 *
475 	 */
setProtectionBit(int val)476 	public void setProtectionBit(int val)
477 	{
478 		if (impl != null)
479 			impl.setProtectionBit(val);
480 
481 		Protection_bit = val;
482 	}
483 
484 	/**
485 	 *
486 	 */
getFrameTimeLength()487 	public double getFrameTimeLength()
488 	{
489 		return (impl == null ? Time_length : impl.getFrameTimeLength());
490 	}
491 
492 	/**
493 	 *
494 	 */
setFrameTimeLength(double val)495 	public void setFrameTimeLength(double val)
496 	{
497 		if (impl != null)
498 			impl.setFrameTimeLength(val);
499 
500 		Time_length = val;
501 	}
502 
503 ///////
504 
505 	/**
506 	 *
507 	 */
getLastID()508 	public int getLastID()
509 	{
510 		return (impl == null ? lID : impl.getLastID());
511 	}
512 
513 	/**
514 	 *
515 	 */
setLastID(int val)516 	public void setLastID(int val)
517 	{
518 		if (impl != null)
519 			impl.setLastID(val);
520 
521 		lID = val;
522 	}
523 
524 	/**
525 	 *
526 	 */
getLastLayer()527 	public int getLastLayer()
528 	{
529 		return (impl == null ? lLayer : impl.getLastLayer());
530 	}
531 
532 	/**
533 	 *
534 	 */
setLastLayer(int val)535 	public void setLastLayer(int val)
536 	{
537 		if (impl != null)
538 			impl.setLastLayer(val);
539 
540 		lLayer = val;
541 	}
542 
543 	/**
544 	 *
545 	 */
getLastBitrate()546 	public int getLastBitrate()
547 	{
548 		return (impl == null ? lBitrate : impl.getLastBitrate());
549 	}
550 
551 	/**
552 	 *
553 	 */
setLastBitrate(int val)554 	public void setLastBitrate(int val)
555 	{
556 		if (impl != null)
557 			impl.setLastBitrate(val);
558 
559 		lBitrate = val;
560 	}
561 
562 	/**
563 	 *
564 	 */
getLastSamplingFrequency()565 	public int getLastSamplingFrequency()
566 	{
567 		return (impl == null ? lSampling_frequency : impl.getLastSamplingFrequency());
568 	}
569 
570 	/**
571 	 *
572 	 */
setLastSamplingFrequency(int val)573 	public void setLastSamplingFrequency(int val)
574 	{
575 		if (impl != null)
576 			impl.setLastSamplingFrequency(val);
577 
578 		lSampling_frequency = val;
579 	}
580 
581 	/**
582 	 *
583 	 */
getLastMode()584 	public int getLastMode()
585 	{
586 		return (impl == null ? lMode : impl.getLastMode());
587 	}
588 
589 	/**
590 	 *
591 	 */
setLastMode(int val)592 	public void setLastMode(int val)
593 	{
594 		if (impl != null)
595 			impl.setLastMode(val);
596 
597 		lMode = val;
598 	}
599 
600 	/**
601 	 *
602 	 */
getLastModeExtension()603 	public int getLastModeExtension()
604 	{
605 		return (impl == null ? lMode_extension : impl.getLastModeExtension());
606 	}
607 
608 	/**
609 	 *
610 	 */
setLastModeExtension(int val)611 	public void setLastModeExtension(int val)
612 	{
613 		if (impl != null)
614 			impl.setLastModeExtension(val);
615 
616 		lMode_extension = val;
617 	}
618 
619 	/**
620 	 *
621 	 */
getLastEmphasis()622 	public int getLastEmphasis()
623 	{
624 		return (impl == null ? lEmphasis : impl.getLastEmphasis());
625 	}
626 
627 	/**
628 	 *
629 	 */
setLastEmphasis(int val)630 	public void setLastEmphasis(int val)
631 	{
632 		if (impl != null)
633 			impl.setLastEmphasis(val);
634 
635 		lEmphasis = val;
636 	}
637 
638 	/**
639 	 *
640 	 */
getLastSize()641 	public int getLastSize()
642 	{
643 		return (impl == null ? lSize : impl.getLastSize());
644 	}
645 
646 	/**
647 	 *
648 	 */
setLastSize(int val)649 	public void setLastSize(int val)
650 	{
651 		if (impl != null)
652 			impl.setLastSize(val);
653 
654 		lSize = val;
655 	}
656 
657 	/**
658 	 *
659 	 */
getLastSizeBase()660 	public int getLastSizeBase()
661 	{
662 		return (impl == null ? lSize_base : impl.getLastSizeBase());
663 	}
664 
665 	/**
666 	 *
667 	 */
setLastSizeBase(int val)668 	public void setLastSizeBase(int val)
669 	{
670 		if (impl != null)
671 			impl.setLastSizeBase(val);
672 
673 		lSize_base = val;
674 	}
675 
676 	/**
677 	 *
678 	 */
getLastChannel()679 	public int getLastChannel()
680 	{
681 		return (impl == null ? lChannel : impl.getLastChannel());
682 	}
683 
684 	/**
685 	 *
686 	 */
setLastChannel(int val)687 	public void setLastChannel(int val)
688 	{
689 		if (impl != null)
690 			impl.setLastChannel(val);
691 
692 		lChannel = val;
693 	}
694 
695 	/**
696 	 *
697 	 */
getLastPaddingBit()698 	public int getLastPaddingBit()
699 	{
700 		return (impl == null ? lPadding_bit : impl.getLastPaddingBit());
701 	}
702 
703 	/**
704 	 *
705 	 */
setLastPaddingBit(int val)706 	public void setLastPaddingBit(int val)
707 	{
708 		if (impl != null)
709 			impl.setLastPaddingBit(val);
710 
711 		lPadding_bit = val;
712 	}
713 
714 	/**
715 	 *
716 	 */
getLastPrivateBit()717 	public int getLastPrivateBit()
718 	{
719 		return (impl == null ? lPrivate_bit : impl.getLastPrivateBit());
720 	}
721 
722 	/**
723 	 *
724 	 */
setLastPrivateBit(int val)725 	public void setLastPrivateBit(int val)
726 	{
727 		if (impl != null)
728 			impl.setLastPrivateBit(val);
729 
730 		lPrivate_bit = val;
731 	}
732 
733 	/**
734 	 *
735 	 */
getLastOriginal()736 	public int getLastOriginal()
737 	{
738 		return (impl == null ? lOriginal : impl.getLastOriginal());
739 	}
740 
741 	/**
742 	 *
743 	 */
setLastOriginal(int val)744 	public void setLastOriginal(int val)
745 	{
746 		if (impl != null)
747 			impl.setLastOriginal(val);
748 
749 		lOriginal = val;
750 	}
751 
752 	/**
753 	 *
754 	 */
getLastCopyright()755 	public int getLastCopyright()
756 	{
757 		return (impl == null ? lCopyright : impl.getLastCopyright());
758 	}
759 
760 	/**
761 	 *
762 	 */
setLastCopyright(int val)763 	public void setLastCopyright(int val)
764 	{
765 		if (impl != null)
766 			impl.setLastCopyright(val);
767 
768 		lCopyright = val;
769 	}
770 
771 	/**
772 	 *
773 	 */
getLastProtectionBit()774 	public int getLastProtectionBit()
775 	{
776 		return (impl == null ? lProtection_bit : impl.getLastProtectionBit());
777 	}
778 
779 	/**
780 	 *
781 	 */
setLastProtectionBit(int val)782 	public void setLastProtectionBit(int val)
783 	{
784 		if (impl != null)
785 			impl.setLastProtectionBit(val);
786 
787 		lProtection_bit = val;
788 	}
789 
790 	/**
791 	 *
792 	 */
getLastFrameTimeLength()793 	public double getLastFrameTimeLength()
794 	{
795 		return (impl == null ? lTime_length : impl.getLastFrameTimeLength());
796 	}
797 
798 	/**
799 	 *
800 	 */
setLastFrameTimeLength(double val)801 	public void setLastFrameTimeLength(double val)
802 	{
803 		if (impl != null)
804 			impl.setLastFrameTimeLength(val);
805 
806 		lTime_length = val;
807 	}
808 
809 ///////
810 
811 
812 	/**
813 	 *
814 	 */
getNextID()815 	public int getNextID()
816 	{
817 		return (impl == null ? nID : impl.getNextID());
818 	}
819 
820 	/**
821 	 *
822 	 */
setNextID(int val)823 	public void setNextID(int val)
824 	{
825 		if (impl != null)
826 			impl.setNextID(val);
827 
828 		nID = val;
829 	}
830 
831 	/**
832 	 *
833 	 */
getNextLayer()834 	public int getNextLayer()
835 	{
836 		return (impl == null ? nLayer : impl.getNextLayer());
837 	}
838 
839 	/**
840 	 *
841 	 */
setNextLayer(int val)842 	public void setNextLayer(int val)
843 	{
844 		if (impl != null)
845 			impl.setNextLayer(val);
846 
847 		nLayer = val;
848 	}
849 
850 	/**
851 	 *
852 	 */
getNextBitrate()853 	public int getNextBitrate()
854 	{
855 		return (impl == null ? nBitrate : impl.getNextBitrate());
856 	}
857 
858 	/**
859 	 *
860 	 */
setNextBitrate(int val)861 	public void setNextBitrate(int val)
862 	{
863 		if (impl != null)
864 			impl.setNextBitrate(val);
865 
866 		nBitrate = val;
867 	}
868 
869 	/**
870 	 *
871 	 */
getNextSamplingFrequency()872 	public int getNextSamplingFrequency()
873 	{
874 		return (impl == null ? nSampling_frequency : impl.getNextSamplingFrequency());
875 	}
876 
877 	/**
878 	 *
879 	 */
setNextSamplingFrequency(int val)880 	public void setNextSamplingFrequency(int val)
881 	{
882 		if (impl != null)
883 			impl.setNextSamplingFrequency(val);
884 
885 		nSampling_frequency = val;
886 	}
887 
888 	/**
889 	 *
890 	 */
getNextMode()891 	public int getNextMode()
892 	{
893 		return (impl == null ? nMode : impl.getNextMode());
894 	}
895 
896 	/**
897 	 *
898 	 */
setNextMode(int val)899 	public void setNextMode(int val)
900 	{
901 		if (impl != null)
902 			impl.setNextMode(val);
903 
904 		nMode = val;
905 	}
906 
907 	/**
908 	 *
909 	 */
getNextModeExtension()910 	public int getNextModeExtension()
911 	{
912 		return (impl == null ? nMode_extension : impl.getNextModeExtension());
913 	}
914 
915 	/**
916 	 *
917 	 */
setNextModeExtension(int val)918 	public void setNextModeExtension(int val)
919 	{
920 		if (impl != null)
921 			impl.setNextModeExtension(val);
922 
923 		nMode_extension = val;
924 	}
925 
926 	/**
927 	 *
928 	 */
getNextEmphasis()929 	public int getNextEmphasis()
930 	{
931 		return (impl == null ? nEmphasis : impl.getNextEmphasis());
932 	}
933 
934 	/**
935 	 *
936 	 */
setNextEmphasis(int val)937 	public void setNextEmphasis(int val)
938 	{
939 		if (impl != null)
940 			impl.setNextEmphasis(val);
941 
942 		nEmphasis = val;
943 	}
944 
945 	/**
946 	 *
947 	 */
getNextSize()948 	public int getNextSize()
949 	{
950 		return (impl == null ? nSize : impl.getNextSize());
951 	}
952 
953 	/**
954 	 *
955 	 */
setNextSize(int val)956 	public void setNextSize(int val)
957 	{
958 		if (impl != null)
959 			impl.setNextSize(val);
960 
961 		nSize = val;
962 	}
963 
964 	/**
965 	 *
966 	 */
getNextSizeBase()967 	public int getNextSizeBase()
968 	{
969 		return (impl == null ? nSize_base : impl.getNextSizeBase());
970 	}
971 
972 	/**
973 	 *
974 	 */
setNextSizeBase(int val)975 	public void setNextSizeBase(int val)
976 	{
977 		if (impl != null)
978 			impl.setNextSizeBase(val);
979 
980 		nSize_base = val;
981 	}
982 
983 	/**
984 	 *
985 	 */
getNextChannel()986 	public int getNextChannel()
987 	{
988 		return (impl == null ? nChannel : impl.getNextChannel());
989 	}
990 
991 	/**
992 	 *
993 	 */
setNextChannel(int val)994 	public void setNextChannel(int val)
995 	{
996 		if (impl != null)
997 			impl.setNextChannel(val);
998 
999 		nChannel = val;
1000 	}
1001 
1002 	/**
1003 	 *
1004 	 */
getNextPaddingBit()1005 	public int getNextPaddingBit()
1006 	{
1007 		return (impl == null ? nPadding_bit : impl.getNextPaddingBit());
1008 	}
1009 
1010 	/**
1011 	 *
1012 	 */
setNextPaddingBit(int val)1013 	public void setNextPaddingBit(int val)
1014 	{
1015 		if (impl != null)
1016 			impl.setNextPaddingBit(val);
1017 
1018 		nPadding_bit = val;
1019 	}
1020 
1021 	/**
1022 	 *
1023 	 */
getNextPrivateBit()1024 	public int getNextPrivateBit()
1025 	{
1026 		return (impl == null ? nPrivate_bit : impl.getNextPrivateBit());
1027 	}
1028 
1029 	/**
1030 	 *
1031 	 */
setNextPrivateBit(int val)1032 	public void setNextPrivateBit(int val)
1033 	{
1034 		if (impl != null)
1035 			impl.setNextPrivateBit(val);
1036 
1037 		nPrivate_bit = val;
1038 	}
1039 
1040 	/**
1041 	 *
1042 	 */
getNextOriginal()1043 	public int getNextOriginal()
1044 	{
1045 		return (impl == null ? nOriginal : impl.getNextOriginal());
1046 	}
1047 
1048 	/**
1049 	 *
1050 	 */
setNextOriginal(int val)1051 	public void setNextOriginal(int val)
1052 	{
1053 		if (impl != null)
1054 			impl.setNextOriginal(val);
1055 
1056 		nOriginal = val;
1057 	}
1058 
1059 	/**
1060 	 *
1061 	 */
getNextCopyright()1062 	public int getNextCopyright()
1063 	{
1064 		return (impl == null ? nCopyright : impl.getNextCopyright());
1065 	}
1066 
1067 	/**
1068 	 *
1069 	 */
setNextCopyright(int val)1070 	public void setNextCopyright(int val)
1071 	{
1072 		if (impl != null)
1073 			impl.setNextCopyright(val);
1074 
1075 		nCopyright = val;
1076 	}
1077 
1078 	/**
1079 	 *
1080 	 */
getNextProtectionBit()1081 	public int getNextProtectionBit()
1082 	{
1083 		return (impl == null ? nProtection_bit : impl.getNextProtectionBit());
1084 	}
1085 
1086 	/**
1087 	 *
1088 	 */
setNextProtectionBit(int val)1089 	public void setNextProtectionBit(int val)
1090 	{
1091 		if (impl != null)
1092 			impl.setNextProtectionBit(val);
1093 
1094 		nProtection_bit = val;
1095 	}
1096 
1097 	/**
1098 	 *
1099 	 */
getNextFrameTimeLength()1100 	public double getNextFrameTimeLength()
1101 	{
1102 		return (impl == null ? nTime_length : impl.getNextFrameTimeLength());
1103 	}
1104 
1105 	/**
1106 	 *
1107 	 */
setNextFrameTimeLength(double val)1108 	public void setNextFrameTimeLength(double val)
1109 	{
1110 		if (impl != null)
1111 			impl.setNextFrameTimeLength(val);
1112 
1113 		nTime_length = val;
1114 	}
1115 
1116 
1117 
1118 
1119 //////
1120 
1121 	/**
1122 	 *
1123 	 */
parseHeader(byte[] data, int offset, int endoffset)1124 	public int parseHeader(byte[] data, int offset, int endoffset)
1125 	{
1126 		int ret = 0;
1127 
1128 		if (impl != null)
1129 		{
1130 			for (int i = 0; i < endoffset; i++)
1131 				if ((ret = parseHeader(data, offset + i)) < 0)
1132 					continue;
1133 		}
1134 
1135 		return ret;
1136 	}
1137 
1138 	/**
1139 	 *
1140 	 */
parseHeader(byte[] frame, int offset)1141 	public int parseHeader(byte[] frame, int offset)
1142 	{
1143 		return (impl == null ? 0 : impl.parseHeader(frame, offset));
1144 	}
1145 
1146 	/**
1147 	 *
1148 	 */
parseNextHeader(byte[] frame, int offset)1149 	public int parseNextHeader(byte[] frame, int offset)
1150 	{
1151 		return (impl == null ? 0 : impl.parseNextHeader(frame, offset));
1152 	}
1153 
1154 	/**
1155 	 * save last header
1156 	 */
saveHeader()1157 	public void saveHeader()
1158 	{
1159 		setLastID(getID());
1160 		setLastLayer(getLayer());
1161 		setLastProtectionBit(getProtectionBit());
1162 		setLastPrivateBit(getPrivateBit());
1163 		setLastBitrate(getBitrate());
1164 		setLastSamplingFrequency(getSamplingFrequency());
1165 		setLastPaddingBit(getPaddingBit());
1166 		setLastPrivateBit(getPrivateBit());
1167 		setLastMode(getMode());
1168 		setLastModeExtension(getModeExtension());
1169 		setLastCopyright(getCopyright());
1170 		setLastOriginal(getOriginal());
1171 		setLastChannel(getChannel());
1172 		setLastEmphasis(getEmphasis());
1173 		setLastSize(getSize());
1174 		setLastSizeBase(getSizeBase());
1175 		setLastFrameTimeLength(getFrameTimeLength());
1176 	}
1177 
1178 	/**
1179 	 *
1180 	 */
compareHeader()1181 	public int compareHeader()
1182 	{
1183 		return (impl == null ? 0 : impl.compareHeader());
1184 	}
1185 
1186 	/**
1187 	 *
1188 	 */
displayHeader()1189 	public String displayHeader()
1190 	{
1191 		return (impl == null ? "" : impl.displayHeader());
1192 	}
1193 
1194 	/**
1195 	 * save and display last header
1196 	 */
saveAndDisplayHeader()1197 	public String saveAndDisplayHeader()
1198 	{
1199 		saveHeader();
1200 
1201 		return displayHeader();
1202 	}
1203 
1204 	/**
1205 	 *
1206 	 */
editFrame(byte[] frame, int mode)1207 	public byte[] editFrame(byte[] frame, int mode)
1208 	{
1209 		return (impl == null ? frame : impl.editFrame(frame, mode));
1210 	}
1211 
1212 	/**
1213 	 *
1214 	 */
convertFrame(byte[] frame, int mode)1215 	public byte[][] convertFrame(byte[] frame, int mode)
1216 	{
1217 		if (impl == null)
1218 			return (new byte[][]{ frame, new byte[0] });
1219 
1220 		return impl.convertFrame(frame, mode);
1221 //		return (impl == null ? frame : impl.convertFrame(frame, mode));
1222 	}
1223 
1224 	/**
1225 	 *
1226 	 */
removeCRC(byte[] frame, boolean remove)1227 	public void removeCRC(byte[] frame, boolean remove)
1228 	{
1229 		if (impl != null)
1230 			impl.removeCRC(frame, remove);
1231 	}
1232 
1233 	/**
1234 	 *
1235 	 */
validateCRC(byte[] frame, int offset, int len)1236 	public int validateCRC(byte[] frame, int offset, int len)
1237 	{
1238 		return (impl == null ? 0 : impl.validateCRC(frame, offset, len));
1239 	}
1240 
1241 	/**
1242 	 *
1243 	 */
setAncillaryDataDecoder(boolean b1, boolean b2)1244 	public void setAncillaryDataDecoder(boolean b1, boolean b2)
1245 	{
1246 		if (impl != null)
1247 			impl.setAncillaryDataDecoder(b1, b2);
1248 	}
1249 
1250 	/**
1251 	 *
1252 	 */
decodeAncillaryData(byte[] frame, double frametime)1253 	public String decodeAncillaryData(byte[] frame, double frametime)
1254 	{
1255 		return (impl == null ? null : impl.decodeAncillaryData(frame, frametime));
1256 	}
1257 
1258 	/**
1259 	 *
1260 	 */
parseRiffData(byte[] frame, int channel)1261 	public void parseRiffData(byte[] frame, int channel)
1262 	{
1263 		if (impl != null)
1264 			impl.parseRiffData(frame, channel);
1265 	}
1266 
1267 	/**
1268 	 *
1269 	 */
initExtraWaveHeader(boolean bool_ACM, boolean bool_BWF, boolean bool_AC3)1270 	public void initExtraWaveHeader(boolean bool_ACM, boolean bool_BWF, boolean bool_AC3)
1271 	{
1272 		if (impl != null)
1273 			impl.initExtraWaveHeader(bool_ACM, bool_BWF, bool_AC3);
1274 	}
1275 
1276 	/**
1277 	 *
1278 	 */
getExtraWaveHeader(int channel, boolean placeholder)1279 	public byte[] getExtraWaveHeader(int channel, boolean placeholder)
1280 	{
1281 		return (impl == null ? (new byte[0]) : impl.getExtraWaveHeader(channel, placeholder));
1282 	}
1283 
1284 	/**
1285 	 *
1286 	 */
setExtraWaveData(int[] array, int channel)1287 	public void setExtraWaveData(int[] array, int channel)
1288 	{
1289 		if (impl != null)
1290 			impl.setExtraWaveData(array, channel);
1291 	}
1292 
1293 	/**
1294 	 *
1295 	 */
setExtraWaveLength(long filelength, long timelength, int channel)1296 	public void setExtraWaveLength(long filelength, long timelength, int channel)
1297 	{
1298 		if (impl != null)
1299 			impl.setExtraWaveLength(filelength, timelength, channel);
1300 	}
1301 
1302 	/**
1303 	 * returns RIFF
1304 	 */
getRiffHeader()1305 	public byte[] getRiffHeader()
1306 	{
1307 		return (new byte[] {
1308 			0x52, 0x49, 0x46, 0x46,  //'RIFF'
1309 			0, 0, 0, 0,  // all size LSB
1310 			0x57, 0x41, 0x56, 0x45, //'WAVE'
1311 			0x66, 0x6D, 0x74, 0x20, //'fmt '
1312 			0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1313 			0, 0, 0, 0,
1314 			0x64, 0x61, 0x74, 0x61, // 'data'
1315 			0, 0, 0, 0  // data size LSB
1316 		});
1317 	}
1318 
1319 	/**
1320 	 * updates std RIFF
1321 	 */
fillStdRiffHeader(String file, long time_len)1322 	public void fillStdRiffHeader(String file, long time_len)
1323 	{
1324 		try {
1325 			RandomAccessFile riff = new RandomAccessFile(file, "rw");
1326 
1327 			int len = (int) riff.length() - 8;
1328 			int bitrate = 1411200;
1329 
1330 			riff.seek(4);
1331 			riff.writeInt(littleEndian(len, 4, true));  //data+chunksize
1332 
1333 			riff.seek(16);
1334 			riff.writeInt(littleEndian(0x10, 4, true));  //chunk length
1335 			riff.writeShort(littleEndian(1, 2, true));   //pcm
1336 			riff.writeShort((short)littleEndian(2, 2, true)); //channels
1337 			riff.writeInt(littleEndian(44100, 4, true));  //sample_freq
1338 			riff.writeInt(littleEndian(bitrate / 8, 4, true)); //byterate
1339 			riff.writeShort((short)littleEndian(4, 2, true)); //blockalign
1340 			riff.writeShort((short)littleEndian(16, 2, true)); //bits_per_sample
1341 
1342 			riff.seek(40);
1343 			riff.writeInt(littleEndian(len - 36, 4, true));  //data-size
1344 
1345 			riff.close();
1346 
1347 		} catch (IOException e) {
1348 			Common.setExceptionMessage(e);
1349 		}
1350 	}
1351 
1352 	/**
1353 	 * updates RIFF
1354 	 * returns playtime as int
1355 	 */
fillRiffHeader(String file)1356 	public long fillRiffHeader(String file)
1357 	{
1358 		long value = 0;
1359 
1360 		try {
1361 			RandomAccessFile riff = new RandomAccessFile(file, "rw");
1362 
1363 			int len = (int)riff.length() - 8;
1364 
1365 			riff.seek(3);
1366 
1367 			if (!isINTEL())
1368 				riff.write((byte)'X');
1369 
1370 			riff.seek(4);
1371 			riff.writeInt(littleEndian(len, 4));  //data+chunksize
1372 
1373 			riff.seek(16);
1374 			riff.writeInt(littleEndian(0x10, 4));  //chunk length
1375 			riff.writeShort(littleEndian(1, 2));   //pcm
1376 			riff.writeShort((short)littleEndian(lChannel, 2)); //channels
1377 			riff.writeInt(littleEndian(lSampling_frequency, 4));  //sample_freq
1378 			riff.writeInt(littleEndian(lBitrate / 8, 4)); //byterate
1379 			riff.writeShort((short)littleEndian(lMode, 2)); //blockalign
1380 			riff.writeShort((short)littleEndian(lSize, 2)); //bits_per_sample
1381 
1382 			riff.seek(40);
1383 			riff.writeInt(littleEndian(len - 36, 4));  //data-size
1384 
1385 			riff.close();
1386 
1387 			value = (8000L * (len - 36)) / lBitrate;
1388 
1389 		} catch (IOException e) {
1390 			Common.setExceptionMessage(e);
1391 		}
1392 
1393 		return value;
1394 	}
1395 
1396 
1397 	/**
1398 	 *
1399 	 */
littleEndian(byte[] data, int offset, int len, boolean reverse)1400 	public int littleEndian(byte[] data, int offset, int len, boolean reverse)
1401 	{
1402 		int value = 0;
1403 
1404 		for (int a = 0; a < len; a++)
1405 			value |= reverse ? ((0xFF & data[offset + a])<<(a * 8)) : ((0xFF & data[offset + a])<<((len - 1 - a) * 8));
1406 
1407 		return value;
1408 	}
1409 
1410 	/**
1411 	 *
1412 	 */
getValue(byte[] data, int offset, int len, boolean reverse)1413 	public int getValue(byte[] data, int offset, int len, boolean reverse)
1414 	{
1415 		return littleEndian(data, offset, len, reverse);
1416 	}
1417 
1418 	/**
1419 	 *
1420 	 */
setValue(byte[] array, int offset, int len, boolean bytereordering, int value)1421 	public void setValue(byte[] array, int offset, int len, boolean bytereordering, int value)
1422 	{
1423 		for (int i = 0; bytereordering && i < len; i++)
1424 			array[i + offset] = (byte)(0xFF & (value>>>(i * 8)));
1425 
1426 		for (int i = 0, j = len - 1; !bytereordering && i < len; i++, j--)
1427 			array[i + offset] = (byte)(0xFF & (value>>>(j * 8)));
1428 	}
1429 
1430 	/**
1431 	 *
1432 	 */
littleEndian(int data, int len)1433 	public int littleEndian(int data, int len)
1434 	{
1435 		return littleEndian(data, len, isINTEL());
1436 	}
1437 
1438 	/**
1439 	 *
1440 	 */
littleEndian(int data, int len, boolean b)1441 	public int littleEndian(int data, int len, boolean b)
1442 	{
1443 		if (!b)
1444 			return data;
1445 
1446 		if (len == 4)
1447 			return ( (0xFF & data>>>24) | (0xFF & data>>>16)<<8 | (0xFF & data>>>8)<<16 | (0xFF & data)<<24 );
1448 
1449 		else
1450 			return ( (0xFF & data>>>8) | (0xFF & data)<<8 );
1451 	}
1452 
1453 	/**
1454 	 *
1455 	 */
getBits(byte buf[], int BitPos[], int N)1456 	public int getBits(byte buf[], int BitPos[], int N)
1457 	{
1458 		int Pos, Val;
1459 
1460 		Pos = BitPos[0]>>>3;
1461 
1462 		Val = (0xFF & buf[Pos])<<24 |
1463 			(0xFF & buf[Pos+1])<<16 |
1464 			(0xFF & buf[Pos+2])<<8 |
1465 			(0xFF & buf[Pos+3]);
1466 
1467 		Val <<= BitPos[0] & 7;
1468 		Val >>>= 32-N;
1469 		BitPos[0] += N;
1470 
1471 		return Val;
1472 	}
1473 
1474 }