main.cc

传输流分析

        int fd;
        int progn;
        int err = 0;

        for (progn = 0; progn < PROGS+1; progn ++)
                if (!strcmp(basename(argv[0]), prognames[progn]))
                        break;

        if (progn == PROGS+1 && argc > 1)
                for (progn = 0; progn < PROGS+1; progn ++)
                        if (!strcmp(basename(argv[1]), prognames[progn])) {
                                argc--;
                                argv++;
                                break;
                        }

        if (progn == PROGS+1) {
                for (progn = 0; progn < PROGS;progn++) {
                        usage(progn);
                        cerr << endl;
                }
                exit(1);
        }
        cerr << prognames[progn] << endl;

        if (argc >=2 && !strcmp(argv[1],"-h")) {
                usage(progn);
                exit(1);
        }

        if(argc <=2) {

                if (progn == get_http_) {
                        if (argc < 2) {
                                usage(progn);
                                exit(1);
                        }
                        int sock = http_open(argv[1]);

                        if (sock >= 0) {
                                int count = 1;
                                uint8_t buf[SIZE];
                                while (count > 0) {
                                        count = read(sock,buf,SIZE);
                                        write(STDOUT_FILENO,buf, count);
                                }

                        }
                        exit(0);
                }
                if (argc == 2 && progn != pes_repack_ && progn != ts2es_
                                && progn != extract_pes_
                                && progn != extract_pes_payload_) {
                        if ((fd = open(argv[1],O_RDONLY|O_LARGEFILE))< 0) {
                                perror(argv[1]);
                                exit(1);
                        }
                } else {
                        fd = STDIN_FILENO;
                }

                switch( progn ) {
                case streamtype_: {
                                char *streams[4] = { "PS_STREAM", "TS_STREAM"
                                                     , "PES_STREAM"};
                                char *tv_form[3] = {"DUNNO", "PAL", "NTSC"};

                                int f;
                                if (fd == STDIN_FILENO) {
                                        cout << streams[stream_type(cin)] << endl;
                                        f=tv_norm(cin);
                                } else {
                                        close(fd);
                                        if (argc < 2) {
                                                usage(progn);
                                                exit(1);
                                        }

                                        ifstream fin(argv[1]);
                                        cout << streams[stream_type(fin)] << endl;
                                        f=tv_norm(fin);
                                }
                                cout << tv_form[int(f&0x0F)] << endl;
                                cout << "MPEG" << int((f>>4)&0x0F) << endl;
                        }
                        break;

                case insert_pat_pmt_:
                        insert_pat_pmt( fd, STDOUT_FILENO);
                        break;

                case extract_pes_payload_: {
                                if (argc < 2) {
                                        usage(progn);
                                        exit(1);
                                }

                                istringstream arg(argv[1]);
                                int id;
                                arg >> hex >> id;
                                extract_from_pes(fd, STDOUT_FILENO, id, 1);
                                break;
                        }

                case extract_pes_: {
                                if (argc < 2) {
                                        usage(progn);
                                        exit(1);
                                }
                                istringstream arg(argv[1]);
                                int id;
                                arg >> hex >> id;
                                extract_from_pes(fd, STDOUT_FILENO, id, 0);
                                break;
                        }

                case pes2vid_:
                        extract_from_pes(fd, STDOUT_FILENO, 0xE0, 0);
                        break;

                case pes2aud_:
                        extract_from_pes(fd, STDOUT_FILENO, 0xC0, 0);
                        break;

                case pes2vid_es_:
                        extract_from_pes(fd, STDOUT_FILENO, 0xE0, 1);
                        break;

                case pes2aud_es_:
                        extract_from_pes(fd, STDOUT_FILENO, 0xC0, 1);
                        break;


                case pes2ts_: {
                                p2t_t p;
                                uint8_t buf[SIZE];

                                init_p2t(&p,NULL);
                                int count = 1;
                                while (count > 0) {
                                        count = read(fd,buf,SIZE);
                                        pes_to_ts(buf, count, 160, &p);
                                }
                        }
                        break;

                case ts_demux_:
                        cerr << "Opening stderr for audio" << endl;
                        cerr << "Opening stdout for video" << endl;

                        ts_demux(fd,STDOUT_FILENO,STDERR_FILENO,0,0,0);
                        break;

                case tspids_:
                        if (fd == STDIN_FILENO) {
                                TS_PIDS(cin,cout);
                        } else {
                                close(fd);
                                if (argc < 2) {
                                        usage(progn);
                                        exit(1);
                                }

                                ifstream fin(argv[1]);
                                TS_PIDS(cin,cout);
                        }
                        break;

                case analyze_:
                        if (fd == STDIN_FILENO) {
                                analyze(cin);
                        } else {
                                close(fd);
                                if (argc < 2) {
                                        usage(progn);
                                        exit(1);
                                }

                                ifstream fin(argv[1]);
                                analyze(fin);
                        }
                        break;

                case change_aspect_1_1_:
                        change_aspect( fd, STDOUT_FILENO, 0x10);
                        break;
                case change_aspect_4_3_:
                        change_aspect( fd, STDOUT_FILENO, 0x20);
                        break;
                case change_aspect_16_9_:
                        change_aspect( fd, STDOUT_FILENO, 0x30);
                        break;
                case change_aspect_221_1_:
                        change_aspect( fd, STDOUT_FILENO, 0x40);
                        break;

                case pes_repack_: {
                                uint8_t buf[SIZE];
                                int count = 1;
                                if (argc < 2) {
                                        usage(progn);
                                        exit(1);
                                }

                                int size = strtol(argv[1],(char **)NULL,0);
                                //			p2p p;
                                ipack p;

                                if (fd != STDIN_FILENO) {
                                        usage(progn);
                                        exit(1);
                                }
                                cerr << "Repacking int size " << size << endl;
                                //			init_p2p(&p, write_it, size);
                                init_ipack(&p, size, write_it2, 0);

                                while (count > 0) {
                                        count = read(fd,buf,SIZE);
                                        //				get_pes(buf,count,&p,pes_repack);
                                        instant_repack(buf,count,&p);
                                }
                        }
                        break;

                case ts2es_:
                        if (fd != STDIN_FILENO || argc < 2) {
                                usage(progn);
                                exit(1);
                        }
                        ts2es(fd, strtol(argv[1],(char **)NULL,0));
                        break;

                case pesplot_: {
                                PES_Packet pes;
                                long int apts=0;
                                long int vpts=0;

                                if (fd == STDIN_FILENO) {
                                        cerr << "Can't read from stdin" << endl;
                                        exit(1);
                                }
                                close(fd);
                                if (argc < 2) {
                                        usage(progn);
                                        exit(1);
                                }


                                ifstream fin(argv[1]);

                                while(!fin.eof()) {
                                        streampos pos=fin.tellg();
                                        fin >> pes;
                                        if(pes.has_pts()) {
                                                switch(pes.Stream_ID()) {
                                                case AUDIO_STREAM_S ... AUDIO_STREAM_E:
                                                        apts = ntohl(*((unsigned int *)
                                                                       pes.P()->pts));
                                                        break;
                                                case VIDEO_STREAM_S ... VIDEO_STREAM_E: