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 }