jTsSplitter/trunk/src/jtssplitter/calc.java

   1 /*
   2  * jTsSplitter - java based mpeg2ts splitter.
   3  * Copyright (C) 2009-2012 Yukikaze
   4  */
   5
   6 package jtssplitter;
   7
   8 /**
   9  *
  10  * @author yukikaze
  11  */
  12 public class calc {
  13    public String Int2String(int num, int length) {
  14         String ret = Integer.toBinaryString(num);
  15         if (ret.length() < length) {
  16             int it = length - ret.length();
  17             for (int i = 0; i < it; i++) {
  18                 ret = "0" + ret;
  19             }
  20         }
  21         return ret;
  22     }
  23    public String Long2String(long num, int length) {
  24         String ret = Long.toBinaryString(num);
  25         if (ret.length() < length) {
  26             int it = length - ret.length();
  27             for (int i = 0; i < it; i++) {
  28                 ret = "0" + ret;
  29             }
  30         }
  31         return ret;
  32     }
  33     public byte[] String2Byte(String ts) {
  34         //StringBuffer sb=new StringBuffer(ts);
  35         int len = ts.length() - ts.length() % 8;
  36         len = len / 8;
  37         byte[] ret = new byte[len];
  38         for (int i = 0; i < len; i++) {
  39             String tet = ts.substring(i * 8, i * 8 + 8);
  40             int itt = TSString2Int(tet, 0, 8);
  41             ret[i] = (byte) itt;
  42         }
  43         return ret;
  44     }
  45     public byte joinByte(byte b1,byte b2,int b2length){
  46         byte ret=(byte)(b1<<(b2length)&0xFF+b2&0xFF);
  47         return ret;
  48     }
  49     public byte joinByte(byte b1,byte b2,int b2len,byte b3,int b3len){
  50         byte ret=joinByte(b1,b2,b2len);
  51         ret=joinByte(ret, b3, b3len);
  52         return ret;
  53     }
  54     public String byte2String(byte[] b) {
  55         StringBuffer sb=new StringBuffer(8*b.length);
  56         for (int i = 0; i < b.length; i++) {
  57             StringBuffer sb2=new StringBuffer(8);
  58             sb2.append(Integer.toBinaryString(b[i] & 0xFF));
  59             if ((sb2.length() < 8) & (sb2.length() > 0)) {
  60                 sb2.insert(0,addzero(8-sb2.length()));
  61             }
  62             sb.append(sb2);
  63         }
  64         return sb.toString();
  65     }
  66     public String byte2String2(byte[] b){
  67         int bl=b.length;
  68         bl=bl-bl%8;
  69         bl=bl/8;
  70         StringBuffer sb=new StringBuffer();
  71         for (int i=0;i<bl;i++){
  72             long retl=0;
  73             for (int j=0;j<8;j++){
  74                 retl=retl<<8;
  75                 int ri=b[i*8+j]&0xFF;
  76                 retl=retl+ri;
  77             }
  78             sb.append(Long2String(retl,64));
  79         }
  80         int bl2=b.length%8;
  81         bl2=(bl2-bl2%4)/4;
  82         for (int i=0;i<bl2;i++){
  83             int reti=0;
  84             for (int j=0;j<4;j++){
  85                 reti=reti<<8;
  86                 reti=reti+(b[bl*8+4*i+j]&0xFF);
  87             }
  88             sb.append(Int2String(reti,32));
  89         }
  90         for (int i=0;i<(b.length%8)%4;i++){
  91             sb.append(Int2String(b[bl*8+bl2*4+i]&0xFF,8));
  92         }
  93         return sb.toString();
  94     }
  95
  96     public String byte2HexString(byte[] b) {
  97         String ret = "";
  98         for (int i = 0; i < b.length; i++) {
  99             ret = ret + Integer.toHexString(b[i] & 0xFF);
 100         }
 101         return ret;
 102     }
 103     public String addzero(int num){
 104         switch (num){
 105             case 0:
 106                 return "";
 107             case 1:
 108                 return "0";
 109             case 2:
 110                 return "00";
 111             case 3:
 112                 return "000";
 113             case 4:
 114                 return "0000";
 115             case 5:
 116                 return "00000";
 117             case 6:
 118                 return "000000";
 119             case 7:
 120                 return "0000000";
 121             case 8:
 122                 return "00000000";
 123             default:
 124                 StringBuffer sb=new StringBuffer();
 125                 for (int i=0;i<num;i++){
 126                     sb.append("0");
 127                 }
 128                 return sb.toString();
 129         }
 130     }
 131     public int TSString2Int(String s, int begin, int length) {
 132         String st = s.substring(begin, begin + length);
 133         int i = Integer.parseInt(st, 2);
 134         return i;
 135     }
 136     public byte[] byte2subbyte(byte[] b,int start,int length){
 137         byte[] ret=new byte[length];
 138         System.arraycopy(b,start,ret,0, length);
 139         return ret;
 140     }
 141     public int byte2int(byte[] b,int startbit,int length){
 142         int a=startbit-startbit%8;
 143         a=a/8;
 144         int bb=startbit+length-(startbit+length)%8;
 145         bb=bb/8;
 146         int ret=0;
 147         for (int i=0;i<bb-a+1;i++){
 148             if (i==0){
 149                 int tt=1;
 150                 for (int j=0;j<(8-(startbit%8));j++){
 151                     tt=tt*2;
 152                 }
 153                 tt=tt-1;
 154                 int lent=length-8+(startbit%8);
 155                 if (lent<0){
 156                     lent=0;
 157                 }
 158                 ret=ret+(((b[a]&0xFF)&tt)<<lent);
 159                 if (i==bb-a){
 160                     int k=0;
 161                     if ((startbit+length)%8==0){
 162                         k=0;
 163                     }else{
 164                         k=8-(startbit+length)%8;
 165                 }
 166                     ret=ret>>k;
 167                 }
 168             }else if (i==bb-a){
 169                 int k=0;
 170                 if ((startbit+length)%8==0){
 171                     k=8;
 172                 }else{
 173                     k=8-(startbit+length)%8;
 174                 }
 175                 ret=ret+((b[a+i]&0xFF)>>k);
 176             }else{
 177                 ret=ret+((b[a+i]&0xFF)<<((bb-a-i-1)*8+((startbit+length)%8)));
 178             }
 179             if (b.length-1-a==i){
 180                 i=bb-a+1;
 181             }
 182         }
 183         return ret;
 184     }
 185     public long byte2long(byte[] b,int startbit,int length){
 186         int a=startbit-startbit%8;
 187         a=a/8;
 188         int bb=startbit+length-(startbit+length)%8;
 189         bb=bb/8;
 190         long ret=0;
 191         for (int i=0;i<bb-a+1;i++){
 192             if (i==0){
 193                 int tt=1;
 194                 for (int j=0;j<(8-(startbit%8));j++){
 195                     tt=tt*2;
 196                 }
 197                 tt=tt-1;
 198                 int lent=length-8+(startbit%8);
 199                 if (lent<0){
 200                     lent=0;
 201                 }
 202                 ret=ret+(((b[a]&0xFF)&tt)<<lent);
 203                 if (i==bb-a){
 204                     int k=0;
 205                     if ((startbit+length)%8==0){
 206                         k=0;
 207                     }else{
 208                         k=8-(startbit+length)%8;
 209                 }
 210                     ret=ret>>k;
 211                 }
 212             }else if (i==bb-a){
 213                 int k=0;
 214                 if ((startbit+length)%8==0){
 215                     k=8;
 216                 }else{
 217                     k=8-(startbit+length)%8;
 218                 }
 219                 ret=ret+((b[a+i]&0xFF)>>k);
 220             }else{
 221                 ret=ret+((b[a+i]&0xFF)<<((bb-a-i-1)*8+((startbit+length)%8)));
 222             }
 223         }
 224         return ret;
 225     }
 226     public void showPAT(String ts) {
 227         System.out.println("先頭:" + ts.substring(0, 8));
 228         System.out.println("" + ts.substring(8, 11));
 229         System.out.println("PID:" + ts.substring(11, 24));
 230         System.out.println("" + ts.substring(24, 32));
 231         System.out.println("Adap_Len:" + ts.substring(32, 40));
 232         System.out.println("TableID:" + ts.substring(40, 48));
 233         System.out.println("" + ts.substring(48, 52));
 234         System.out.println("len : " + ts.substring(52, 64) + "//" + Integer.toString(Integer.parseInt(ts.substring(52, 64), 2)));
 235         System.out.println("TS ID:" + ts.substring(64, 80));
 236         System.out.println("11:" + ts.substring(80, 82));
 237         System.out.println("" + ts.substring(82, 104));
 238         for (int i = 0; i < 10; i++) {
 239             System.out.println(Integer.toString(i) + " : " + ts.substring(104 + 32 * i, 136 + 32 * i));
 240         }
 241         System.out.println("Length:" + Integer.toString(ts.length()));
 242     }
 243     public byte[] getCRC32_byte(byte[] data, int offset) {
 244         // x^32 + x^26 + x^23 + x^22 + x^16 + x^12 + x^11 + x^10 + x^8 + x^7 + x^5 + x^4 + x^2 + x + 1
 245         int[] g = {1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1};
 246         int[] shift_reg = new int[32];
 247         long crc = 0;
 248         byte crc32[] = new byte[4];
 249
 250         // Initialize shift register's to '1'
 251         java.util.Arrays.fill(shift_reg, 1);
 252
 253         // Calculate nr of data bits, summa of bits
 254         int nr_bits = (data.length - offset) * 8;
 255
 256         for (int bit_count = 0, bit_in_byte = 0, data_bit; bit_count < nr_bits; bit_count++) {
 257             // Fetch bit from bitstream
 258             data_bit = (data[offset] & 0x80 >>> (bit_in_byte++)) != 0 ? 1 : 0;
 259
 260             if ((bit_in_byte &= 7) == 0) {
 261                 offset++;
 262             }
 263
 264             // Perform the shift and modula 2 addition
 265             data_bit ^= shift_reg[31];
 266
 267             for (int i = 31; i > 0; i--) {
 268                 shift_reg[i] = g[i] == 1 ? (shift_reg[i - 1] ^ data_bit) : shift_reg[i - 1];
 269             }
 270
 271             shift_reg[0] = data_bit;
 272         }
 273
 274         for (int i = 0; i < 32; i++) {
 275             crc = ((crc << 1) | (shift_reg[31 - i]));
 276         }
 277
 278         for (int i = 0; i < 4; i++) {
 279             crc32[i] = (byte) (0xFF & (crc >>> ((3 - i) * 8)));
 280         }
 281         return crc32;
 282     }
 283 }