libepg.ts.reader.Reader2.java Source code

Introduction

Here is the source code for libepg.ts.reader.Reader2.java

Source

/*
 * Copyright (C) 2016 normal
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
package libepg.ts.reader;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PushbackInputStream;
import java.lang.invoke.MethodHandles;
import java.nio.ByteBuffer;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import libepg.ts.packet.TsPacket;
import libepg.util.db.AboutDB;
import static libepg.util.db.AboutDB.INSERT_SQL;
import loggingsupport.loggerfactory.LoggerFactory;
import org.apache.commons.codec.binary.Hex;
import org.apache.commons.logging.Log;

/**
 * ?TS????????? ??????1???
 *
 * @author normal
 */
public class Reader2 {

    /**
     * ?????true????
     * ???????trace???????????ts???(1GB????)?????????????
     */
    public static final boolean NOT_DETERRENT_READ_TRACE_LOG = false;

    /**
     * false?????????????
     */
    public static final boolean CLASS_LOG_OUTPUT_MODE = true;

    private static final Log LOG;

    static {
        final Class<?> myClass = MethodHandles.lookup().lookupClass();
        LOG = new LoggerFactory(myClass, TsReader.CLASS_LOG_OUTPUT_MODE).getLOG();
        if (NOT_DETERRENT_READ_TRACE_LOG == false) {
            LOG.info("??");
        }
    }

    /**
     * ??????
     *
     * @see java.io.FileInputStream#read()
     */
    public static final int EOF = -1;

    private final File TSFile;
    private final Long readLimit;

    /**
     * ?TS?????
     * ?1??????????1??????
     *
     * @author normal
     * @param TSFile ?
     * @param readLimit ??<br>
     * ????????????????<br>
     * @throws java.io.FileNotFoundException ??????????
     */
    public Reader2(File TSFile, Long readLimit) throws FileNotFoundException {
        this.TSFile = new File(TSFile.getAbsolutePath());
        if (this.TSFile.isFile() == false) {
            throw new FileNotFoundException("TS?????");
        }
        this.readLimit = readLimit;
        if (this.readLimit != null) {
            if (this.readLimit < 0) {
                throw new IllegalArgumentException("????0??");
            }
            LOG.info("???" + this.readLimit
                    + "???????");
        } else {
            LOG.info("??????????");
        }
    }

    /**
     * ?TS????
     * ?1??????????1??????
     *
     * @author normal
     * @param TSFile ?
     * @throws java.io.FileNotFoundException ??????????
     */
    public Reader2(File TSFile) throws FileNotFoundException {
        this(TSFile, null);
    }

    /**
     * ??????<br>
     * 1:???????????1??????<br>
     * 2:?????????????<br>
     * 3:??????1??????<br>
     * ???????????<br>
     * 4:1?<br>
     *
     * @return ???
     */
    public synchronized List<TsPacket> getPackets() {
        ByteBuffer packetBuffer = ByteBuffer.allocate(TsPacket.TS_PACKET_BYTE_LENGTH.PACKET_LENGTH.getByteLength());
        byte[] byteData = new byte[1];

        //?
        List<TsPacket> packets = new ArrayList<>();

        FileInputStream fis = null;
        PushbackInputStream pis = null;
        try {

            fis = new FileInputStream(this.TSFile);
            pis = new PushbackInputStream(fis);

            boolean tipOfPacket = false;//?

            long count = 0;

            //??????1??????
            while (pis.read(byteData) != EOF) {

                //???????????????
                if ((byteData[0] == TsPacket.TS_SYNC_BYTE) && (tipOfPacket == false)) {
                    tipOfPacket = true;
                    if (LOG.isTraceEnabled() && NOT_DETERRENT_READ_TRACE_LOG) {
                        LOG.trace(
                                "???????????1????");
                    }
                    pis.unread(byteData);
                }

                if (tipOfPacket == true) {
                    byte[] tsPacketData = new byte[TsPacket.TS_PACKET_BYTE_LENGTH.PACKET_LENGTH.getByteLength()];
                    if (pis.read(tsPacketData) != EOF) {
                        if (LOG.isTraceEnabled() && NOT_DETERRENT_READ_TRACE_LOG) {
                            LOG.trace(
                                    "??????????????");
                        }
                        packetBuffer.put(tsPacketData);
                    } else {
                        break;
                    }
                }

                if (packetBuffer.remaining() == 0) {
                    byte[] BeforeCutDown = packetBuffer.array();
                    byte[] AfterCutDown = new byte[packetBuffer.position()];
                    System.arraycopy(BeforeCutDown, 0, AfterCutDown, 0, AfterCutDown.length);

                    //??????????
                    TsPacket tsp = new TsPacket(AfterCutDown);

                    //                        LOG.debug(Hex.encodeHexString(tsp.getData()));
                    if (LOG.isTraceEnabled() && NOT_DETERRENT_READ_TRACE_LOG) {
                        LOG.trace(
                                "1???????? ");
                        LOG.trace(tsp.toString());
                    }

                    if (tsp.getTransport_error_indicator() != 0) {
                        if (LOG.isWarnEnabled()) {
                            LOG.warn(
                                    "??1????????????????????");
                            LOG.warn(tsp);
                            LOG.warn(TSFile);
                        }
                        tipOfPacket = false;
                    } else {
                        packets.add(tsp);
                        count++;
                    }
                    packetBuffer.clear();
                    tipOfPacket = false;

                    if (this.readLimit != null && count >= this.readLimit) {
                        if (LOG.isInfoEnabled()) {
                            LOG.info(
                                    "????????????? ?? = "
                                            + this.readLimit);
                        }
                        break;
                    }
                }

            }
            if (LOG.isTraceEnabled() && NOT_DETERRENT_READ_TRACE_LOG) {
                LOG.trace("?????????");
                LOG.trace(" = " + Hex.encodeHexString(packetBuffer.array()));
            }

            pis.close();
            fis.close();
            LOG.info("??? = " + count);

        } catch (FileNotFoundException e) {
            LOG.fatal("?????", e);
        } catch (IOException e) {
            LOG.fatal("???", e);
        }
        return Collections.unmodifiableList(packets);
    }

}