Recherche avancée

Sur d’autres sites (18141)

• How to stop recording dynamically in FFMPEG CLI Wrapper java

  14 décembre 2017, par user2237529

  https://github.com/bramp/ffmpeg-cli-wrapper/issues/13

  public class ScreenCaptureFFMPEG {
  
  
  
      public static void record(String outputVideo, String time) throws Exception
  
      {
  
          RunProcessFunction func = new RunProcessFunction();
  
  
  
          FFmpeg ffmpeg = new FFmpeg("C:\\FFMPEG\\ffmpeg.exe");
  
          FFmpegBuilder builder = new FFmpegBuilder()
  
                  .addExtraArgs("-rtbufsize", "1500M")
  
                  .addExtraArgs("-r", "30")
  
                  .setFormat("dshow")
  
                  .setInput("video=\"screen-capture-recorder\"")
  
                  .addOutput(outputVideo)
  
                  .setFormat("mp4")
  
                  .addExtraArgs("-crf", "0")
  
                  .setVideoCodec("libx264")
  
                  //.addExtraArgs("-ac", "1")
  
                  .addExtraArgs("-y")
  
          //overwrite file name
  
  
  
                  // .setAudioCodec("libmp3lame")
  
                  // .setAudioSampleRate(FFmpeg.AUDIO_SAMPLE_44100)
  
                  //  .setAudioBitRate(1_000_000)
  
  
  
                  //.addExtraArgs("-ar", "44100")
  
                  .addExtraArgs("-t", time)
  
  
  
                  //.setVideoPixelFormat("yuv420p")
  
                  //.setVideoResolution(426, 240)
  
                  //.setVideoBitRate(2_000_000)
  
                  //.setVideoFrameRate(30)
  
                  //.addExtraArgs("-deinterlace")
  
                  //.addExtraArgs("-preset", "medium")
  
                  //.addExtraArgs("-g", "30")
  
                  .done();
  
          FFmpegExecutor executor = new FFmpegExecutor(ffmpeg);
  
  
  
          executor.createJob(builder).run();
  
  
  
  
  
      }
  
  
  
      public static void capture(String name) throws Exception
  
      {
  
          BufferedImage image = new Robot().createScreenCapture(new Rectangle(Toolkit.getDefaultToolkit().getScreenSize()));
  
          ImageIO.write(image, "png", new File(name));
  
  
  
      }
  
  
  
      public static void main(String[]args) throws Exception {
  
  
  
          capture("start.png");
  
          //record("TC_test.mp4", "00:00:10");
  
          capture("end.png");
  
          Thread t = new Thread(new Runnable() {
  
              @Override
  
              public void run() {
  
                  // Insert some method call here.
  
                  try {
  
                      record("TC_test.mp4", "00:00:10");
  
                  }
  
                  catch(Exception e)
  
                  {
  
                      System.out.println("hello");
  
                  }
  
              }
  
          });
  
          Thread.sleep(5000);
  
  
  
          t.interrupt();
  
  
  
      }
  
  }

  I am trying to stop the recording by killing the subprocess or if there is any other method its fine too. But I am unable to do that. I know its supported according to the github link. How do I kill a subprocess please ?

  PS : THis is the first time i post a question on stackoverflow so If I made any mistakes please excuse me and provide details on how i can improve

• video proccesing : extract frames and encrypt them then insert them back to the video in java using xuggler

  24 juillet 2015, par Anas M. Jubara

  I’m working on a video encryption application .. the main idea is to input the video file to the application and the application should output it in an encrypted form... am using xuggler library to manipulate the video and get to the frames and AES for encryption.
  my code works fine for accessing the frames and encrypting them, what i need help with is how to write the encrypted frame back to the video file to replace the original one without corrupting the video file for the video players.
  Here is my code

  package xuggler;
  
  
  
  import com.xuggle.mediatool.IMediaReader;
  
  import com.xuggle.mediatool.IMediaWriter;
  
  import com.xuggle.mediatool.MediaListenerAdapter;
  
  import com.xuggle.mediatool.ToolFactory;
  
  import com.xuggle.mediatool.event.IVideoPictureEvent;
  
  import com.xuggle.xuggler.Global;
  
  import com.xuggle.xuggler.ICodec;
  
  
  
  import java.awt.Graphics2D;
  
  import java.awt.Point;
  
  import java.awt.Transparency;
  
  import java.awt.image.BufferedImage;
  
  import java.awt.image.ColorModel;
  
  import java.awt.image.ComponentColorModel;
  
  import java.awt.image.DataBuffer;
  
  import java.awt.image.DataBufferByte;
  
  import java.awt.image.Raster;
  
  import java.awt.image.WritableRaster;
  
  
  
  import java.io.File;
  
  
  
  import java.security.InvalidKeyException;
  
  import java.security.NoSuchAlgorithmException;
  
  import java.security.SecureRandom;
  
  
  
  import java.util.concurrent.TimeUnit;
  
  import java.util.logging.Level;
  
  import java.util.logging.Logger;
  
  
  
  import javax.crypto.BadPaddingException;
  
  import javax.crypto.Cipher;
  
  import javax.crypto.IllegalBlockSizeException;
  
  import javax.crypto.KeyGenerator;
  
  import javax.crypto.NoSuchPaddingException;
  
  import javax.crypto.SecretKey;
  
  
  
  import javax.imageio.ImageIO;
  
  
  
  
  
  public class DecodeAndCaptureFrames extends MediaListenerAdapter
  
  {
  
  
  
   // The number of seconds between frames.
  
        public static final double SECONDS_BETWEEN_FRAMES = 5;
  
  
  
    //The number of micro-seconds between frames.
  
    public static final long MICRO_SECONDS_BETWEEN_FRAMES =(long)      (Global.DEFAULT_PTS_PER_SECOND * SECONDS_BETWEEN_FRAMES);
  
  
  
    // Time of last frame write
  
    private static long mLastPtsWrite = Global.NO_PTS;
  
  
  
  private static final double FRAME_RATE = 50;
  
  
  
  private static final int SECONDS_TO_RUN_FOR = 20;
  
  
  
  private static final String outputFilename = "D:\\K.mp4";
  
  
  
  public static IMediaWriter writer = ToolFactory.makeWriter(outputFilename);
  
  //receive BufferedImage and returns its byte data
  
      public static byte[] get_byte_data(BufferedImage image) {
  
      WritableRaster raster = image.getRaster();
  
      DataBufferByte buffer = (DataBufferByte) raster.getDataBuffer();
  
      return buffer.getData();
  
  }
  
  
  
  
  
  //create new_img with the attributes of image
  
  public static BufferedImage user_space(BufferedImage image) {
  
      //create new_img with the attributes of image
  
      BufferedImage new_img = new BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_3BYTE_BGR);
  
      Graphics2D graphics = new_img.createGraphics();
  
      graphics.drawRenderedImage(image, null);
  
      graphics.dispose(); //release all allocated memory for this image
  
      return new_img;
  
  }
  
  
  
  public static BufferedImage toImage(byte[] imagebytes, int width, int height) {
  
      DataBuffer buffer = new DataBufferByte(imagebytes, imagebytes.length);
  
      WritableRaster raster = Raster.createInterleavedRaster(buffer, width, height,
  
         3 * width, 3, new int[]{2, 1, 0}, (Point) null);
  
  
  
      ColorModel cm = new ComponentColorModel(ColorModel.getRGBdefault().getColorSpace(), 
  
              false, true, Transparency.OPAQUE, DataBuffer.TYPE_BYTE);
  
      return new BufferedImage(cm, raster, true, null);
  
  }
  
  
  
  public static byte[] encrypt(byte[] orgnlbytes, String key) throws NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {
  
      byte[] encbytes = null;
  
      try {
  
          Cipher cipher = Cipher.getInstance("AES");
  
          KeyGenerator keyGen = KeyGenerator.getInstance("AES");
  
          SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
  
          // cryptograph. secure random
  
          random.setSeed(key.getBytes());
  
  
  
          keyGen.init(128, random);
  
          // for example
  
          SecretKey secretKey = keyGen.generateKey();
  
          try {
  
              cipher.init(Cipher.ENCRYPT_MODE, secretKey);
  
          } catch (InvalidKeyException ex) {
  
              Logger.getLogger(DecodeAndCaptureFrames.class.getName()).log(Level.SEVERE, null, ex);
  
          }
  
          encbytes = cipher.doFinal(orgnlbytes);
  
      }
  
      catch (NoSuchAlgorithmException ex) {
  
          Logger.getLogger(DecodeAndCaptureFrames.class.getName()).log(Level.SEVERE, null, ex);
  
      }        catch (NoSuchPaddingException ex)
  
      {
  
          System.out.print("can not encrypt buffer");
  
      }
  
  
  
      return encbytes;
  
  }
  
  
  
  
  
    /**
  
     * The video stream index, used to ensure we display frames from one
  
     * and only one video stream from the media container.
  
     */
  
  
  
    private int mVideoStreamIndex = -1;
  
  
  
    /**
  
     * Takes a media container (file) as the first argument, opens it and
  
     *  writes some of it's video frames to PNG image files in the
  
     *  temporary directory.
  
     *
  
     * @param args must contain one string which represents a filename
  
     */
  
  
  
    public static void main(String[] args)
  
    {
  
      // create a new mr. decode and capture frames
  
  
  
  
  
      DecodeAndCaptureFrames decodeAndCaptureFrames;
  
      decodeAndCaptureFrames = new DecodeAndCaptureFrames("D:\\K.mp4");
  
    } 
  
  
  
    /** Construct a DecodeAndCaptureFrames which reads and captures
  
     * frames from a video file.
  
     *
  
     * @param filename the name of the media file to read
  
     */
  
  
  
  
  
    //makes reader to the file and read the data of it
  
    public DecodeAndCaptureFrames(String filename)
  
    {
  
      // create a media reader for processing video
  
  
  
     IMediaReader reader = ToolFactory.makeReader(filename);
  
  
  
  // stipulate that we want BufferedImages created in BGR 24bit color space
  
  reader.setBufferedImageTypeToGenerate(BufferedImage.TYPE_3BYTE_BGR);
  
  
  
  
  
  // note that DecodeAndCaptureFrames is derived from
  
  // MediaReader.ListenerAdapter and thus may be added as a listener
  
  // to the MediaReader. DecodeAndCaptureFrames implements
  
  // onVideoPicture().
  
  
  
  reader.addListener(this);
  
  
  
  // read out the contents of the media file, note that nothing else
  
  // happens here.  action happens in the onVideoPicture() method
  
  // which is called when complete video pictures are extracted from
  
  // the media source
  
  
  
  while (reader.readPacket() == null)
  
    do {} while(false);
  
    }
  
  
  
   /**
  
     * Called after a video frame has been decoded from a media stream.
  
     * Optionally a BufferedImage version of the frame may be passed
  
     * if the calling {@link IMediaReader} instance was configured to
  
     * create BufferedImages.
  
     *
  
     * This method blocks, so return quickly.
  
     */
  
  
  
    public void onVideoPicture(IVideoPictureEvent event)
  
    {
  
      try
  
      {
  
        // if the stream index does not match the selected stream index,
  
        // then have a closer look
  
  
  
    if (event.getStreamIndex() != mVideoStreamIndex)
  
    {
  
      // if the selected video stream id is not yet set, go ahead an
  
      // select this lucky video stream
  
  
  
      if (-1 == mVideoStreamIndex)
  
        mVideoStreamIndex = event.getStreamIndex();
  
  
  
      // otherwise return, no need to show frames from this video stream
  
  
  
      else
  
        return;
  
    }
  
  
  
    // if uninitialized, backdate mLastPtsWrite so we get the very
  
    // first frame
  
  
  
    if (mLastPtsWrite == Global.NO_PTS)
  
      mLastPtsWrite = event.getTimeStamp() - MICRO_SECONDS_BETWEEN_FRAMES;
  
  
  
    // if it's time to write the next frame
  
  
  
    if (event.getTimeStamp() - mLastPtsWrite >= MICRO_SECONDS_BETWEEN_FRAMES)
  
    {
  
      // Make a temporary file name
  
  
  
     // File file = File.createTempFile("frame", ".jpeg");
  
  
  
      // write out PNG
  
  
  
  //        ImageIO.write(event.getImage(), "png", file);
  
  
  
      BufferedImage orgnlimage = event.getImage();
  
          orgnlimage = user_space(orgnlimage);
  
          byte[] orgnlimagebytes = get_byte_data(orgnlimage);
  
          byte[] encryptedbytes = encrypt(orgnlimagebytes, "abc");
  
          BufferedImage encryptedimage = toImage(encryptedbytes, orgnlimage.getWidth(), orgnlimage.getHeight());
  
  
  
  
  
          ImageIO.write(encryptedimage, "png", File.createTempFile("frame", ".png"));
  
  //         indicate file written
  
  
  
      double seconds = ((double)event.getTimeStamp())
  
        / Global.DEFAULT_PTS_PER_SECOND;
  
  //        System.out.printf("at elapsed time of %6.3f seconds wrote: %s\n",seconds, file);
  
  
  
      // update last write time
  
  
  
      mLastPtsWrite += MICRO_SECONDS_BETWEEN_FRAMES;
  
    }
  
  }
  
  catch (Exception e)
  
  {
  
    e.printStackTrace();
  
  }
  
    }
  
  
  
  }

• How to convert ogv video file into Mp4 video format using Java

  16 février 2016, par Srinivasan Seenu

  I need to convert OGV VIDEO Format into MP4 VIDEO Format.

  • I use this below Java code to convert MP4 VIDEO Format to OGV VIDEO Format it is working fine.
  • For MP4 Format I use audio.setCodec(" AudioAttributes.DIRECT_STREAM_COPY") and video.setCodec("VideoAttributes.DIRECT_STREAM_COPY ").

  • But If I use this same code by change audio.setCodec(" libvorbis") and video.setCodec("mpeg4 ") it is not getting converted from Ogv to Mp4 Format. And also I try some codec in my sample program.

  • I am not able convert from Ogv to Mp4 Format.

  public class VideoConvert {
  
      public static void main(String[] args) throws IOException {
  
      File source = new File("D:\\readxml\\videoConvertorProject\\MP4toOGV\\mp4\\Sample1.ogv");
  
      File target = new File("D:\\readxml\\videoConvertorProject\\MP4toOGV\\ogv\\Sample2.mp4");
  
      AudioAttributes audio = new AudioAttributes();
  
      //audio.setCodec("libvorbis");
  
      audio.setCodec("libfaac");
  
      //audio.setCodec("libmp3lame");
  
      //audio.setCodec(AudioAttributes.DIRECT_STREAM_COPY);
  
      audio.setBitRate(new Integer(128000));
  
      audio.setSamplingRate(new Integer(44100));
  
      audio.setChannels(new Integer(2));
  
      VideoAttributes video = new VideoAttributes();
  
      video.setBitRate(new Integer(160000));
  
      video.setFrameRate(new Integer(15));
  
      //video.setSize(new VideoSize(176, 144));
  
      //video.setCodec("libtheora");
  
      video.setCodec("mpeg4");
  
      //video.setCodec(VideoAttributes.DIRECT_STREAM_COPY);
  
      EncodingAttributes attrs = new EncodingAttributes();
  
      attrs.setFormat("mp4");
  
      attrs.setAudioAttributes(audio);
  
      attrs.setVideoAttributes(video);
  
      Encoder encoder = new Encoder();
  
      try {
  
          encoder.encode(source, target, attrs);
  
      } catch (IllegalArgumentException e) {
  
          e.printStackTrace();
  
      } catch (InputFormatException e) {
  
          e.printStackTrace();
  
      } catch (EncoderException e) {
  
          e.printStackTrace();
  
      }
  
  }