public static Format detectFormat(ByteBuffer b) {
    int movScore = MP4Demuxer.probe(b.duplicate());
    int psScore = MPSDemuxer.probe(b.duplicate());
    int tsScore = MTSDemuxer.probe(b.duplicate());

    if (movScore == 0 && psScore == 0 && tsScore == 0)
        return null;

    return movScore > psScore ? (movScore > tsScore ? Format.MOV : Format.MPEG_TS)
            : (psScore > tsScore ? Format.MPEG_PS : Format.MPEG_TS);
}
 

public FrameGrab(SeekableByteChannel in) throws IOException, JCodecException {
    ByteBuffer header = ByteBuffer.allocate(65536);
    in.read(header);
    header.flip();
    Format detectFormat = JCodecUtil.detectFormat(header);

    switch (detectFormat) {
    case MOV:
        MP4Demuxer d1 = new MP4Demuxer(in);
        videoTrack = d1.getVideoTrack();
        break;
    case MPEG_PS:
        throw new UnsupportedFormatException("MPEG PS is temporarily unsupported.");
    case MPEG_TS:
        throw new UnsupportedFormatException("MPEG TS is temporarily unsupported.");
    default:
        throw new UnsupportedFormatException("Container format is not supported by JCodec");
    }
    decodeLeadingFrames();
}
 

@Override
public Size getSize(VFSLeaf media, String suffix) {
	File file = null;
	if(media instanceof VFSCPNamedItem) {
		media = ((VFSCPNamedItem)media).getDelegate();
	}
	if(media instanceof LocalFileImpl) {
		file = ((LocalFileImpl)media).getBasefile();
	}
	if(file == null) {
		return null;
	}

	if(suffix.equals("mp4") || suffix.equals("m4v")) {
		try(RandomAccessFile accessFile = new RandomAccessFile(file, "r")) {
			FileChannel ch = accessFile.getChannel();
			FileChannelWrapper in = new FileChannelWrapper(ch);
			MP4Demuxer demuxer1 = new MP4Demuxer(in);
			org.jcodec.common.model.Size size = demuxer1.getMovie().getDisplaySize();
			int w = size.getWidth();
			int h = size.getHeight();
			return new Size(w, h, false);
		} catch (Exception | AssertionError e) {
			log.error("Cannot extract size of: " + media, e);
		}
	} else if(suffix.equals("flv")) {
		try(InputStream stream = new FileInputStream(file)) {
			FLVParser infos = new FLVParser();
			infos.parse(stream);
			if(infos.getWidth() > 0 && infos.getHeight() > 0) {
				int w = infos.getWidth();
				int h = infos.getHeight();
				return new Size(w, h, false);
			}
		} catch (Exception e) {
			log.error("Cannot extract size of: " + media, e);
		}
	}

	return null;
}
 

@Override
public void run() {
    File inputFile = new File(inputPath);
    File outputFile = new File(outputPath);

    try {
        MP4Demuxer demuxer = new MP4Demuxer(new AutoFileChannelWrapper(inputFile));
        MP4Muxer muxer = new MP4Muxer(NIOUtils.rwFileChannel(outputFile));


        List<AbstractMP4DemuxerTrack> audioTracks = demuxer.getAudioTracks();
        for (AbstractMP4DemuxerTrack audioTrack : audioTracks) {
            FramesMP4MuxerTrack muxerTrack = muxer.addTrack(TrackType.SOUND, (int) audioTrack.getTimescale());
            muxerTrack.addSampleEntry(audioTrack.getSampleEntries()[0]);
            for (int i = 0; i < audioTrack.getFrameCount(); i++) {
                muxerTrack.addFrame((MP4Packet) audioTrack.nextFrame());
            }
        }

        FramesMP4DemuxerTrack videoTrack = (FramesMP4DemuxerTrack) demuxer.getVideoTrack();
        FramesMP4MuxerTrack muxerTrack = muxer.addTrack(TrackType.VIDEO, (int) videoTrack.getTimescale());

        AVCMP4Adaptor decoder = new AVCMP4Adaptor(videoTrack);
        H264Encoder encoder = new H264Encoder();

        Size size = videoTrack.getMeta().getDimensions();
        long frameCount = videoTrack.getFrameCount();
        List<ByteBuffer> spsList = new ArrayList<ByteBuffer>();
        List<ByteBuffer> ppsList = new ArrayList<ByteBuffer>();

        ByteBuffer outBuffer = ByteBuffer.allocate(size.getWidth() * size.getHeight());
        for (int i = 0; i < frameCount; i++) {
            updateProgress(i, frameCount);

            if (Thread.currentThread().isInterrupted()){
                return;
            }

            MP4Packet packet = videoTrack.nextFrame();
            Picture picture;
            try {
                picture = decoder.decodeFrame(packet, decoder.allocatePicture());
            } catch (Exception ex) {
                continue;
            }
            BufferedImage srcImage = ConverterUtils.toBufferedImage(picture);
            core.getBaseImageProvider().reset();
            core.getBaseImageProvider().setSource(srcImage);

            core.processImage();

            BufferedImage precessedImage = core.getCombinedImage();
            Picture modifiedPicture = ConverterUtils.fromBufferedImage(precessedImage, ColorSpace.YUV420J);

            outBuffer.clear();
            outBuffer = encoder.encodeFrame(modifiedPicture, outBuffer);

            spsList.clear();
            ppsList.clear();
            H264Utils.wipePS(outBuffer, spsList, ppsList);
            H264Utils.encodeMOVPacket(outBuffer);

            MP4Packet modifiedPacket = new MP4Packet(packet, outBuffer);
            muxerTrack.addFrame(modifiedPacket);
        }

        muxerTrack.addSampleEntry(H264Utils.createMOVSampleEntry(spsList, ppsList));

        muxer.writeHeader();
    } catch (Exception e) {
        if (e instanceof ClosedByInterruptException) {
            core.setConvertThreadException(new Exception("Interrupted"));
            return;
        }
        core.setConvertThreadException(e);
    } finally {
      releaseButton();
    }
}
 

public void remux(File tgt, File src, File timecode, Handler handler) throws IOException {
    SeekableByteChannel input = null;
    SeekableByteChannel output = null;
    SeekableByteChannel tci = null;
    try {
        input = readableFileChannel(src);
        output = writableFileChannel(tgt);
        MP4Demuxer demuxer = new MP4Demuxer(input);

        
        TimecodeMP4DemuxerTrack tt = null;
        if (timecode != null) {
            tci = readableFileChannel(src);
            MP4Demuxer tcd = new MP4Demuxer(tci);
            tt = tcd.getTimecodeTrack();
        }

        MP4Muxer muxer = WebOptimizedMP4Muxer.withOldHeader(output, Brand.MOV, demuxer.getMovie());

        List<AbstractMP4DemuxerTrack> at = demuxer.getAudioTracks();
        List<PCMMP4MuxerTrack> audioTracks = new ArrayList<PCMMP4MuxerTrack>();
        for (AbstractMP4DemuxerTrack demuxerTrack : at) {
            PCMMP4MuxerTrack att = muxer.addPCMAudioTrack(((AudioSampleEntry) demuxerTrack
                    .getSampleEntries()[0]).getFormat());
            audioTracks.add(att);
            att.setEdits(demuxerTrack.getEdits());
            att.setName(demuxerTrack.getName());
        }

        AbstractMP4DemuxerTrack vt = demuxer.getVideoTrack();
        FramesMP4MuxerTrack video = muxer.addTrack(VIDEO, (int) vt.getTimescale());
        // vt.open(input);
        video.setTimecode(muxer.addTimecodeTrack((int) vt.getTimescale()));
        copyEdits(vt, video, new Rational((int)vt.getTimescale(), demuxer.getMovie().getTimescale()));
        video.addSampleEntries(vt.getSampleEntries());
        MP4Packet pkt = null;
        while ((pkt = (MP4Packet)vt.nextFrame()) != null) {
            if (tt != null)
                pkt = tt.getTimecode(pkt);
            pkt = processFrame(pkt);
            video.addFrame(pkt);

            for (int i = 0; i < at.size(); i++) {
                AudioSampleEntry ase = (AudioSampleEntry) at.get(i).getSampleEntries()[0];
                int frames = (int) (ase.getSampleRate() * pkt.getDuration() / vt.getTimescale());
                MP4Packet apkt = (MP4Packet)at.get(i).nextFrame();
                audioTracks.get(i).addSamples(apkt.getData());
            }
        }

        MovieBox movie = muxer.finalizeHeader();
        if (handler != null)
            handler.handle(movie);
        muxer.storeHeader(movie);

    } finally {
        NIOUtils.closeQuietly(input);
        NIOUtils.closeQuietly(output);
        NIOUtils.closeQuietly(tci);
    }
}
 

private void doIt(String in) throws Exception {
    SeekableByteChannel raw = null;
    SeekableByteChannel source = null;
    try {
        source = new FileChannelWrapper(new FileInputStream(in).getChannel());

        MP4Demuxer demux = new MP4Demuxer(source);

        H264Decoder decoder = new H264Decoder();

        AbstractMP4DemuxerTrack inTrack = demux.getVideoTrack();

        VideoSampleEntry ine = (VideoSampleEntry) inTrack.getSampleEntries()[0];
        AvcCBox avcC = Box.as(AvcCBox.class, Box.findFirst(ine, LeafBox.class, "avcC"));

        ByteBuffer _rawData = ByteBuffer.allocate(1920 * 1088 * 6);

        decoder.addSps(avcC.getSpsList());
        decoder.addPps(avcC.getPpsList());

        Packet inFrame;

        int sf = 2600;
        AbstractMP4DemuxerTrack dt = (AbstractMP4DemuxerTrack) inTrack;
        dt.gotoFrame(sf);
        while ((inFrame = inTrack.nextFrame()) != null && !inFrame.isKeyFrame())
            ;
        // System.out.println(inFrame.getFrameNo() + " - " +
        // inFrame.isKeyFrame());
        dt.gotoFrame(inFrame.getFrameNo());

        List<Picture> decodedPics = new ArrayList<Picture>();
        int totalFrames = (int) inTrack.getFrameCount(), seqNo = 0;
        for (int i = sf; (inFrame = inTrack.nextFrame()) != null; i++) {
            ByteBuffer data = inFrame.getData();
            List<ByteBuffer> nalUnits = splitMOVPacket(data, avcC);
            _rawData.clear();
            H264Utils.joinNALUnits(nalUnits, _rawData);
            _rawData.flip();

            if (H264Utils.idrSlice(_rawData)) {
                if (raw != null) {
                    raw.close();
                    runJMCompareResults(decodedPics, seqNo);
                    decodedPics = new ArrayList<Picture>();
                    seqNo = i;
                }
                raw = new FileChannelWrapper(new FileOutputStream(coded).getChannel());
                H264Utils.saveStreamParams(avcC, raw);
            }
            raw.write(_rawData);

            decodedPics.add(decoder.decodeFrame(nalUnits,
                    Picture.create((ine.getWidth() + 15) & ~0xf, (ine.getHeight() + 15) & ~0xf, ColorSpace.YUV420)
                            .getData()));
            if (i % 500 == 0)
                System.out.println((i * 100 / totalFrames) + "%");
        }
        if (decodedPics.size() > 0)
            runJMCompareResults(decodedPics, seqNo);
    } finally {
        if (source != null)
            source.close();
        if (raw != null)
            raw.close();
    }
}