jTsSplitter/trunk/src/jtssplitter/Tsfile.java

   1 /*
   2  * To change this template, choose Tools | Templates
   3  * and open the template in the editor.
   4  */
   5
   6 package jtssplitter;
   7 import java.util.ArrayList;
   8 import java.io.*;
   9 import java.util.logging.Level;
  10 import java.util.logging.Logger;
  11 import java.util.Arrays;
  12 import jtssplitter.data.EITData;
  13 import jtssplitter.data.PATData;
  14 import jtssplitter.data.PIDs;
  15 import jtssplitter.data.PMTData;
  16 /**
  17  *
  18  * @author Administrator
  19  */
  20 public class Tsfile {
  21     public void readTs(String fpath){
  22         byte[] tb=new byte[188];
  23         int[] ib=new int[188];
  24         ArrayList<PATData> pat=new ArrayList<PATData>();
  25         ArrayList<PMTData> pmt=new ArrayList<PMTData>();
  26         String[] sb=new String[188];
  27         try {
  28             FileInputStream in = new FileInputStream(fpath);
  29             BufferedInputStream bis=new BufferedInputStream(in);
  30             int[] PIDCount=new int[8200];
  31             for (int i=0;i<3000;i++){
  32                 bis.read(tb);
  33                 String last8;
  34                 Mpeg2TSPacket m2tp;
  35                 m2tp=new Mpeg2TSPacket();
  36                 m2tp.setPAT(pat);
  37                 m2tp.setPMT(pmt);
  38                 m2tp.readTS(tb);
  39                 pat=m2tp.getPAT();
  40                 pmt=m2tp.getPMT();
  41                 PIDCount[m2tp.getPID()]++;
  42             }
  43             for (int i=0;i<8200;i++){
  44                 if (PIDCount[i]>0){
  45                 }
  46             }
  47             for (int i=0;i<188;i++){
  48                 int it=tb[i]& 0xFF;
  49                 ib[i]=it;
  50                 String s=Integer.toBinaryString(it);
  51                 if (s.length()<8){
  52                     for (int i2=s.length();i2<8;i2++){
  53                         s="0"+s;
  54                     }
  55                 sb[i]=s;
  56                 }
  57             }
  58             bis.close();
  59             in.close();
  60         } catch (IOException ex) {
  61             Logger.getLogger(Tsfile.class.getName()).log(Level.SEVERE, null, ex);
  62         }
  63
  64     }
  65     public void splitTS(String origpath,String destpath,int csch){
  66         int[] pids=null;
  67         int p_table=0;
  68         if (csch>0){
  69             p_table=csch;
  70         }else{
  71             p_table=getFirstP_Table(origpath);
  72         }
  73         PIDs pidss=getTablePID(origpath,p_table);
  74         p_table=pidss.Program_Table;
  75         pids=pidss.PIDs;
  76         int pmt_pid=pidss.PMT_PID;
  77         byte[] tb=new byte[188];
  78         try {
  79             FileInputStream in = new FileInputStream(origpath);
  80             FileOutputStream fos=new FileOutputStream(destpath);
  81             BufferedInputStream bis=new BufferedInputStream(in,128*188);
  82             BufferedOutputStream bos=new BufferedOutputStream(fos);
  83             byte[] wbyte=null;
  84             boolean end=false;
  85             int ik=0;
  86             boolean readend=false;
  87             Mpeg2TSPacket m2tpp;
  88             m2tpp=new Mpeg2TSPacket();
  89             while (readend==false){
  90                 byte[] tstt=new byte[3];
  91                 bis.mark(188*2);
  92                 bis.read(tstt);
  93                 bis.reset();
  94                 wbyte=null;
  95                 Mpeg2TSPacket m2tp;
  96                 m2tp=new Mpeg2TSPacket();
  97                 //int ii=m2tpp.getPIDFirst(tstt);
  98                 int ii=m2tpp.getPIDFirst_byte(tstt);
  99                 //if (ii!=i2){
 100                 //    System.out.println("not match");
 101                 //}
 102                 boolean alreadyreaded=false;
 103                 for (int k=0;k<pids.length;k++){
 104                     if (ii==pids[k]){
 105                         alreadyreaded=true;
 106                         int readti=bis.read(tb);
 107                         if ((ii==0)&&(readti>187)){
 108                             //Mpeg2TSPacket m2tp2=new Mpeg2TSPacket();
 109                             wbyte=m2tpp.splitPAT(tb,p_table);
 110                         }else if ((ii==pmt_pid)&&(readti>187)){
 111                             wbyte=tb;
 112                             ArrayList<PMTData> pmtss=m2tpp.readPMT(tb, pmt_pid);
 113                             if (pmtss.size()>0){
 114                                 int[] new_pids=new int[pmtss.size()+3];
 115                                 new_pids[pmtss.size()]=0;
 116                                 new_pids[pmtss.size()+1]=pmt_pid;
 117                                 new_pids[pmtss.size()+2]=pmtss.get(0).PCR_PID;
 118                                 for (int i=0;i<pmtss.size();i++){
 119                                     new_pids[i]=pmtss.get(i).Elementary_PID;
 120                                 }
 121                                 if (!Arrays.equals(pids, new_pids)){
 122                                     pids=new_pids;
 123                                 }
 124                             }
 125
 126                         /*}else if ((ii==0x0012)&&(readti>187)){
 127                             ArrayList<EITData> eitss=m2tpp.readEIT(tb);
 128                          */
 129                         }else if (readti>187){
 130                             wbyte=tb;
 131
 132                         }else {
 133                             readend=true;
 134                         }
 135                         k=pids.length;
 136                     }
 137                 ik++;
 138             }
 139             if (alreadyreaded==false){
 140                 bis.skip(188);
 141             }
 142                 if (wbyte!=null){
 143                     bos.write(wbyte);
 144                 }
 145             }
 146             bis.close();
 147             bos.flush();
 148             bos.close();
 149             in.close();
 150             fos.close();
 151
 152         } catch (IOException ex) {
 153             Logger.getLogger(Tsfile.class.getName()).log(Level.SEVERE, null, ex);
 154         }
 155     }
 156
 157     public void splitTS_byte(String origpath,String destpath,int csch){
 158         int[] pids=null;
 159         int p_table=0;
 160         if (csch>0){
 161             p_table=csch;
 162         }else{
 163             p_table=getFirstP_Table_byte(origpath);
 164         }
 165         PIDs pidss=getTablePID_byte(origpath,p_table);
 166         p_table=pidss.Program_Table;
 167         pids=pidss.PIDs;
 168         int pmt_pid=pidss.PMT_PID;
 169         byte[] tb=new byte[188];
 170         try {
 171             FileInputStream in = new FileInputStream(origpath);
 172             FileOutputStream fos=new FileOutputStream(destpath);
 173             BufferedInputStream bis=new BufferedInputStream(in,128*188);
 174             BufferedOutputStream bos=new BufferedOutputStream(fos);
 175             byte[] wbyte=null;
 176             boolean end=false;
 177             int ik=0;
 178             boolean readend=false;
 179             Mpeg2TSPacket m2tpp;
 180             m2tpp=new Mpeg2TSPacket();
 181             while (readend==false){
 182                 byte[] tstt=new byte[3];
 183                 bis.mark(188*2);
 184                 bis.read(tstt);
 185                 bis.reset();
 186                 wbyte=null;
 187                 Mpeg2TSPacket m2tp;
 188                 m2tp=new Mpeg2TSPacket();
 189                 //int ii=m2tpp.getPIDFirst(tstt);
 190                 int ii=m2tpp.getPIDFirst_byte(tstt);
 191                 //if (ii!=i2){
 192                 //    System.out.println("not match");
 193                 //}
 194                 boolean alreadyreaded=false;
 195                 for (int k=0;k<pids.length;k++){
 196                     if (ii==pids[k]){
 197                         alreadyreaded=true;
 198                         int readti=bis.read(tb);
 199                         if ((ii==0)&&(readti>187)){
 200                             //Mpeg2TSPacket m2tp2=new Mpeg2TSPacket();
 201                             wbyte=m2tpp.splitPAT_byte(tb,p_table);
 202                             //wbyte=m2tpp.splitPAT(tb, p_table);
 203                             /*byte[] wbytet=m2tpp.splitPAT(tb, p_table);
 204                             for (int kk=0;kk<wbyte.length;kk++){
 205                                 if (wbyte[kk]==wbytet[kk]){
 206                                     //System.out.println(":match");
 207                                 }else{
 208                                     System.out.print(kk);
 209                                     System.out.println(":not match");
 210                                 }
 211                             }*/
 212                             //wbyte=wbytet;*/
 213                         }else if ((ii==pmt_pid)&&(readti>187)){
 214                             wbyte=tb;
 215                             ArrayList<PMTData> pmtss=m2tpp.readPMTglobal_byte(tb, pmt_pid);
 216                             if (pmtss.size()>0){
 217                                 int[] new_pids=new int[pmtss.size()+3];
 218                                 new_pids[pmtss.size()]=0;
 219                                 new_pids[pmtss.size()+1]=pmt_pid;
 220                                 new_pids[pmtss.size()+2]=pmtss.get(0).PCR_PID;
 221                                 for (int i=0;i<pmtss.size();i++){
 222                                     new_pids[i]=pmtss.get(i).Elementary_PID;
 223                                 }
 224                                 if (!Arrays.equals(pids, new_pids)){
 225                                     pids=new_pids;
 226                                 }
 227                             }
 228
 229                         /*}else if ((ii==0x0012)&&(readti>187)){
 230                             ArrayList<EITData> eitss=m2tpp.readEIT(tb);
 231                          */
 232                         }else if (readti>187){
 233                             wbyte=tb;
 234
 235                         }else {
 236                             readend=true;
 237                         }
 238                         k=pids.length;
 239                     }
 240                 ik++;
 241             }
 242             if (alreadyreaded==false){
 243                 bis.skip(188);
 244             }
 245                 if (wbyte!=null){
 246                     bos.write(wbyte);
 247                 }
 248             }
 249             bis.close();
 250             bos.flush();
 251             bos.close();
 252             in.close();
 253             fos.close();
 254
 255         } catch (IOException ex) {
 256             Logger.getLogger(Tsfile.class.getName()).log(Level.SEVERE, null, ex);
 257         }
 258     }
 259
 260     private void writeTS(byte[] tspacket,String path){
 261         FileOutputStream fos = null;
 262         try {
 263             fos = new FileOutputStream(path,true);
 264             fos.write(tspacket);
 265             fos.close();
 266         } catch (IOException ex) {
 267             Logger.getLogger(Tsfile.class.getName()).log(Level.SEVERE, null, ex);
 268         } finally {
 269             try {
 270                 fos.close();
 271             } catch (IOException ex) {
 272                 Logger.getLogger(Tsfile.class.getName()).log(Level.SEVERE, null, ex);
 273             }
 274         }
 275     }
 276     private PIDs getTablePID(String fpath,int p_table){
 277         /**
 278          * PIDを取得し、これと思われる必要なPIDを抜き出す。
 279          * @return プログラム番号(return[0])とPIDのリスト(return[1-])
 280          */
 281         FileInputStream in = null;
 282         PIDs pids=new PIDs();
 283         int[] reti=null;
 284         try {
 285             ArrayList<Integer> ret=new ArrayList<Integer>();
 286             byte[] tb = new byte[188];
 287             int[] ib = new int[188];
 288             ArrayList<PATData> pat = new ArrayList<PATData>();
 289             ArrayList<PMTData> pmt = new ArrayList<PMTData>();
 290             String[] sb = new String[188];
 291             in = new FileInputStream(fpath);
 292             //int[] PIDCount = new int[8200];
 293             int imax=1000;
 294             for (int i = 0; i < imax ; i++) {
 295                 in.read(tb);
 296                 String last8;
 297                 Mpeg2TSPacket m2tp;
 298                 m2tp = new Mpeg2TSPacket();
 299                 m2tp.setPAT(pat);
 300                 m2tp.setPMT(pmt);
 301                 m2tp.readTS(tb);
 302                 pat = m2tp.getPAT();
 303                 for (int i2=0;i2<pat.size();i2++){
 304                     PATData patdd=pat.get(i2);
 305                     if (pat.get(i2).Program_TABLE==p_table){
 306                         pat.clear();
 307                         pat.add(patdd);
 308                         m2tp.setPAT(pat);
 309                     }
 310                 }
 311                 ArrayList<PMTData> pmtt=m2tp.getPMT();
 312                 for (int i2=0;i2<pmtt.size();i2++){
 313                     if (!(pmt.contains(pmtt.get(i2)))){
 314                         pmt.add(pmtt.get(i2));
 315                     }
 316                 }
 317                 if ((i==imax-1)&&(pmt.size()==0)){
 318                     imax=imax+500;
 319                 }
 320                 for (int i2=0;i2<pmt.size();i2++){
 321                     int itt=ret.size();
 322                     if (p_table==pmt.get(i2).Program_Table){
 323                         if (!(ret.contains(pmt.get(i2).Elementary_PID))){
 324                             ret.add(pmt.get(i2).Elementary_PID);
 325                             i=imax;
 326                         }
 327                     }
 328                     if (ret.size()==itt){
 329                         imax=imax+100;
 330                     }
 331                 }
 332             }
 333             PATData patd_det=new PATData();
 334             for (int i=0;i<pat.size();i++){
 335                 if (pat.get(i).Program_TABLE==p_table){
 336                     patd_det=pat.get(i);
 337                     i=pat.size();
 338                 }
 339             }
 340             ret.add(0);
 341             ret.add(patd_det.PID);
 342             ret.add(pmt.get(0).Elementary_PID);
 343             for (int i=0;i<pmt.size();i++){
 344                 if (patd_det.Program_TABLE==pmt.get(i).Program_Table){
 345                     if (!(ret.contains(pmt.get(i).Elementary_PID))){
 346                         if ((pmt.get(i).Stream_Type==0x02)||(pmt.get(i).Stream_Type==0x0f)){
 347                             ret.add(pmt.get(i).Elementary_PID);
 348                         }
 349                     }
 350                 }
 351             }
 352             pids.PMT_PID=patd_det.PID;
 353             pids.Program_Table=patd_det.Program_TABLE;
 354             pids.PIDs=new int[ret.size()];
 355             for (int i=0;i<ret.size();i++){
 356                 pids.PIDs[i]=ret.get(i);
 357             }
 358             in.close();
 359         } catch (IOException ex) {
 360             Logger.getLogger(Tsfile.class.getName()).log(Level.SEVERE, null, ex);
 361         } finally {
 362             try {
 363                 in.close();
 364             } catch (IOException ex) {
 365                 Logger.getLogger(Tsfile.class.getName()).log(Level.SEVERE, null, ex);
 366             }
 367         }
 368         return pids;
 369     }
 370     private PIDs getTablePID_byte(String fpath,int p_table){
 371         /**
 372          * PIDを取得し、これと思われる必要なPIDを抜き出す。
 373          * @return プログラム番号(return[0])とPIDのリスト(return[1-])
 374          */
 375         FileInputStream in = null;
 376         PIDs pids=new PIDs();
 377         int[] reti=null;
 378         try {
 379             ArrayList<Integer> ret=new ArrayList<Integer>();
 380             byte[] tb = new byte[188];
 381             int[] ib = new int[188];
 382             ArrayList<PATData> pat = new ArrayList<PATData>();
 383             ArrayList<PMTData> pmt = new ArrayList<PMTData>();
 384             String[] sb = new String[188];
 385             in = new FileInputStream(fpath);
 386             //int[] PIDCount = new int[8200];
 387             int imax=1000;
 388             for (int i = 0; i < imax ; i++) {
 389                 in.read(tb);
 390                 String last8;
 391                 Mpeg2TSPacket m2tp;
 392                 m2tp = new Mpeg2TSPacket();
 393                 m2tp.setPAT(pat);
 394                 m2tp.setPMT(pmt);
 395                 m2tp.readTS(tb);
 396                 pat = m2tp.getPAT();
 397                 for (int i2=0;i2<pat.size();i2++){
 398                     PATData patdd=pat.get(i2);
 399                     if (pat.get(i2).Program_TABLE==p_table){
 400                         pat.clear();
 401                         pat.add(patdd);
 402                         m2tp.setPAT(pat);
 403                     }
 404                 }
 405                 ArrayList<PMTData> pmtt=m2tp.getPMT();
 406                 for (int i2=0;i2<pmtt.size();i2++){
 407                     if (!(pmt.contains(pmtt.get(i2)))){
 408                         pmt.add(pmtt.get(i2));
 409                     }
 410                 }
 411                 if ((i==imax-1)&&(pmt.size()==0)){
 412                     imax=imax+500;
 413                 }
 414                 for (int i2=0;i2<pmt.size();i2++){
 415                     int itt=ret.size();
 416                     if (p_table==pmt.get(i2).Program_Table){
 417                         if (!(ret.contains(pmt.get(i2).Elementary_PID))){
 418                             ret.add(pmt.get(i2).Elementary_PID);
 419                             i=imax;
 420                         }
 421                     }
 422                     if (ret.size()==itt){
 423                         imax=imax+100;
 424                     }
 425                 }
 426             }
 427             PATData patd_det=new PATData();
 428             for (int i=0;i<pat.size();i++){
 429                 if (pat.get(i).Program_TABLE==p_table){
 430                     patd_det=pat.get(i);
 431                     i=pat.size();
 432                 }
 433             }
 434             ret.add(0);
 435             ret.add(patd_det.PID);
 436             ret.add(pmt.get(0).Elementary_PID);
 437             for (int i=0;i<pmt.size();i++){
 438                 if (patd_det.Program_TABLE==pmt.get(i).Program_Table){
 439                     if (!(ret.contains(pmt.get(i).Elementary_PID))){
 440                         if ((pmt.get(i).Stream_Type==0x02)||(pmt.get(i).Stream_Type==0x0f)){
 441                             ret.add(pmt.get(i).Elementary_PID);
 442                         }
 443                     }
 444                 }
 445             }
 446             pids.PMT_PID=patd_det.PID;
 447             pids.Program_Table=patd_det.Program_TABLE;
 448             pids.PIDs=new int[ret.size()];
 449             for (int i=0;i<ret.size();i++){
 450                 pids.PIDs[i]=ret.get(i);
 451             }
 452             in.close();
 453         } catch (IOException ex) {
 454             Logger.getLogger(Tsfile.class.getName()).log(Level.SEVERE, null, ex);
 455         } finally {
 456             try {
 457                 in.close();
 458             } catch (IOException ex) {
 459                 Logger.getLogger(Tsfile.class.getName()).log(Level.SEVERE, null, ex);
 460             }
 461         }
 462         return pids;
 463     }
 464     private int getFirstP_Table(String fpath){
 465         /**
 466          * PIDを取得し、これと思われる必要なPIDを抜き出す。
 467          * @return プログラム番号(return[0])とPIDのリスト(return[1-])
 468          */
 469         FileInputStream in = null;
 470         int[] reti=null;
 471         int[] pat_det=new int[2];
 472         //pat_det[0]=0;
 473         PATData patdd=new PATData();
 474         patdd.PID=0;
 475         try {
 476             ArrayList ret=new ArrayList();
 477             byte[] tb = new byte[188];
 478             int[] ib = new int[188];
 479             ArrayList<PATData> pat = new ArrayList<PATData>();
 480             ArrayList<PMTData> pmt = new ArrayList<PMTData>();
 481             String[] sb = new String[188];
 482             in = new FileInputStream(fpath);
 483             //int[] PIDCount = new int[8200];
 484             int imax=1000;
 485             for (int i = 0; i < imax ; i++) {
 486                 in.read(tb);
 487                 String last8;
 488                 Mpeg2TSPacket m2tp;
 489                 m2tp = new Mpeg2TSPacket();
 490                 m2tp.setPAT(pat);
 491                 m2tp.setPMT(pmt);
 492                 m2tp.readTS(tb);
 493                 pat = m2tp.getPAT();
 494                 pmt = m2tp.getPMT();
 495                 if ((i==imax-1)&&(pmt.size()==0)){
 496                     imax=imax+500;
 497                 }
 498             }
 499
 500             for (int i=0;i<pat.size();i++){
 501                 if (pat.get(i).Program_TABLE>0){
 502                     patdd=pat.get(i);
 503                     i=pat.size();
 504                 }
 505             }
 506         } catch (IOException ex) {
 507             Logger.getLogger(Tsfile.class.getName()).log(Level.SEVERE, null, ex);
 508         } finally {
 509             try {
 510                 in.close();
 511             } catch (IOException ex) {
 512                 Logger.getLogger(Tsfile.class.getName()).log(Level.SEVERE, null, ex);
 513             }
 514         }
 515         return patdd.Program_TABLE;
 516     }
 517
 518
 519     private int getFirstP_Table_byte(String fpath){
 520         /**
 521          * PIDを取得し、これと思われる必要なPIDを抜き出す。
 522          * @return プログラム番号(return[0])とPIDのリスト(return[1-])
 523          */
 524         FileInputStream in = null;
 525         int[] reti=null;
 526         int[] pat_det=new int[2];
 527         //pat_det[0]=0;
 528         PATData patdd=new PATData();
 529         patdd.PID=0;
 530         try {
 531             ArrayList ret=new ArrayList();
 532             byte[] tb = new byte[188];
 533             int[] ib = new int[188];
 534             ArrayList<PATData> pat = new ArrayList<PATData>();
 535             ArrayList<PMTData> pmt = new ArrayList<PMTData>();
 536             String[] sb = new String[188];
 537             in = new FileInputStream(fpath);
 538             //int[] PIDCount = new int[8200];
 539             int imax=1000;
 540             for (int i = 0; i < imax ; i++) {
 541                 in.read(tb);
 542                 String last8;
 543                 Mpeg2TSPacket m2tp;
 544                 m2tp = new Mpeg2TSPacket();
 545                 m2tp.setPAT(pat);
 546                 m2tp.setPMT(pmt);
 547                 m2tp.readTS_byte(tb);
 548                 pat = m2tp.getPAT();
 549                 pmt = m2tp.getPMT();
 550                 if ((i==imax-1)&&(pmt.size()==0)){
 551                     imax=imax+500;
 552                 }
 553             }
 554
 555             for (int i=0;i<pat.size();i++){
 556                 if (pat.get(i).Program_TABLE>0){
 557                     patdd=pat.get(i);
 558                     i=pat.size();
 559                 }
 560             }
 561         } catch (IOException ex) {
 562             Logger.getLogger(Tsfile.class.getName()).log(Level.SEVERE, null, ex);
 563         } finally {
 564             try {
 565                 in.close();
 566             } catch (IOException ex) {
 567                 Logger.getLogger(Tsfile.class.getName()).log(Level.SEVERE, null, ex);
 568             }
 569         }
 570         return patdd.Program_TABLE;
 571     }
 572 }