JavaFX2.2制作播放器播放mp4

最新推荐文章于 2024-07-13 02:44:14 发布
最新推荐文章于 2024-07-13 02:44:14 发布
阅读量382 收藏 3
点赞数
文章标签： python
原文链接：https://my.oschina.net/seamanmei/blog/56006
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

2.0的多媒体只支持播放0n2 VP6编码格式的多媒体文件，现在的2.1可以播放普通的mp4文件了，废话不多少，上图上代码，希望fx在多媒体方面继续加强啊~

鼠标放上去显示进度和播放暂停按钮的

鼠标移开就木有显示那些了。

上代码

import javafx.animation.FadeTransitionBuilder;
import javafx.animation.Interpolator;
import javafx.animation.ParallelTransition;
import javafx.animation.ParallelTransitionBuilder;
import javafx.application.Application;
import javafx.application.Platform;
import javafx.beans.InvalidationListener;
import javafx.beans.Observable;
import javafx.beans.value.ChangeListener;
import javafx.beans.value.ObservableValue;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.geometry.Insets;
import javafx.geometry.Pos;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.control.*;
import javafx.scene.input.MouseEvent;
import javafx.scene.layout.*;
import javafx.scene.media.Media;
import javafx.scene.media.MediaPlayer;
import javafx.scene.media.MediaPlayer.Status;
import javafx.scene.media.MediaView;
import javafx.scene.paint.Color;
import javafx.stage.Stage;
import javafx.util.Duration;

/**
 * A media player with controls for play, pause, stop, seek, and volume. 
 *
 * <a href="http://my.oschina.net/u/244147" class="referer" target="_blank">@see</a>  javafx.scene.media.MediaPlayer
 * <a href="http://my.oschina.net/u/244147" class="referer" target="_blank">@see</a>  javafx.scene.media.Media
 */
public class OverlayMediaPlayer extends Application {
    private static final String MEDIA_URL = "http://10.0.xx.xx/xxx/s.mp4";
    private MediaPlayer mediaPlayer;

    private void init(Stage primaryStage) {
        Group root = new Group();
        primaryStage.setScene(new Scene(root));
        mediaPlayer = new MediaPlayer(new Media(MEDIA_URL));
        mediaPlayer.setAutoPlay(true);
        OverlayMediaPlayer.PlayerPane playerPane = new OverlayMediaPlayer.PlayerPane(mediaPlayer);
        playerPane.setMinSize(480, 360);  
        playerPane.setPrefSize(480, 360);
        playerPane.setMaxSize(480, 360);
      //  getStylesheets().add("ensemble/samples/media/OverlayMediaPlayer.css");
        root.getChildren().add(playerPane);
    }

    public void play() {
        Status status = mediaPlayer.getStatus();
        if (status == Status.UNKNOWN || status == Status.HALTED) {
            return;
        }
        if (status == Status.PAUSED || status == Status.STOPPED || status == Status.READY) {
            mediaPlayer.play();
        }
    }

    @Override public void stop() {
        mediaPlayer.stop();
    }

    static class PlayerPane extends BorderPane {
        private MediaPlayer mp;
        private MediaView mediaView;
        private final boolean repeat = false;
        private boolean stopRequested = false;
        private boolean atEndOfMedia = false;
        private Duration duration;
        private Slider timeSlider;
        private Label playTime;
        private Slider volumeSlider;
        private HBox mediaTopBar;
        private HBox mediaBottomBar;
        private ParallelTransition transition = null;

        @Override protected void layoutChildren() {
            if (mediaView != null && getBottom() != null) {
                mediaView.setFitWidth(getWidth());
                mediaView.setFitHeight(getHeight() - getBottom().prefHeight(-1));
            }
            super.layoutChildren();
            if (mediaView != null) {
                mediaView.setTranslateX((((Pane)getCenter()).getWidth() - mediaView.prefWidth(-1)) / 2);
                mediaView.setTranslateY((((Pane)getCenter()).getHeight() - mediaView.prefHeight(-1)) / 2);
            }
        }

        @Override protected double computeMinWidth(double height) {
            return mediaBottomBar.prefWidth(-1);
        }

        @Override protected double computeMinHeight(double width) {
            return 200;
        }

        @Override protected double computePrefWidth(double height) {
            return Math.max(mp.getMedia().getWidth(), mediaBottomBar.prefWidth(height));
        }

        @Override protected double computePrefHeight(double width) {
            return mp.getMedia().getHeight() + mediaBottomBar.prefHeight(width);
        }

        @Override protected double computeMaxWidth(double height) { return Double.MAX_VALUE; }

        @Override protected double computeMaxHeight(double width) { return Double.MAX_VALUE; }

        public PlayerPane(final MediaPlayer mp) {
            this.mp = mp;
            setId("player-pane");

            mediaView = new MediaView(mp);
            Pane mvPane = new Pane() { };
            mvPane.setId("media-pane");
            mvPane.getChildren().add(mediaView);
            setCenter(mvPane);

            mediaTopBar = HBoxBuilder.create()
                    .padding(new Insets(5, 10, 5, 10))
                    .alignment(Pos.CENTER)
                    .opacity(0)
                    .build();
            BorderPane.setAlignment(mediaTopBar, Pos.CENTER);

            mediaBottomBar = HBoxBuilder.create()
                    .padding(new Insets(5, 10, 5, 10))
                    .alignment(Pos.CENTER)
                    .opacity(0)
                    .build();
            BorderPane.setAlignment(mediaBottomBar, Pos.CENTER);
            
            setOnMouseEntered(new EventHandler<MouseEvent>() {
                @Override public void handle(MouseEvent t) {
                    if (transition != null) transition.stop();
                    transition = ParallelTransitionBuilder.create()
                        .children(
                            FadeTransitionBuilder.create()
                                .node(mediaTopBar)
                                .toValue(1)
                                .duration(Duration.millis(200))
                                .interpolator(Interpolator.EASE_OUT)
                                .build(),
                            FadeTransitionBuilder.create()
                                .node(mediaBottomBar)
                                .toValue(1)
                                .duration(Duration.millis(200))
                                .interpolator(Interpolator.EASE_OUT)
                                .build()
                        )
                        .build();
                    transition.play();
                }
            });
            setOnMouseExited(new EventHandler<MouseEvent>() {
                @Override public void handle(MouseEvent t) {
                    if (transition != null) transition.stop();
                    transition = ParallelTransitionBuilder.create()
                        .children(
                            FadeTransitionBuilder.create()
                                .node(mediaTopBar)
                                .toValue(0)
                                .duration(Duration.millis(800))
                                .interpolator(Interpolator.EASE_OUT)
                                .build(),
                            FadeTransitionBuilder.create()
                                .node(mediaBottomBar)
                                .toValue(0)
                                .duration(Duration.millis(800))
                                .interpolator(Interpolator.EASE_OUT)
                                .build()
                        )
                        .build();
                    transition.play();
                }
            });

            mp.currentTimeProperty().addListener(new ChangeListener<Duration>() {
                @Override
                public void changed(ObservableValue<? extends Duration> observable, Duration oldValue, Duration newValue) {
                    updateValues();
                }
            });
            mp.setOnPlaying(new Runnable() {
                public void run() {
                    if (stopRequested) {
                        mp.pause();
                        stopRequested = false;
                    } 
                }
            });
            mp.setOnReady(new Runnable() {
                public void run() {
                    duration = mp.getMedia().getDuration();
                    updateValues();
                }
            });
            mp.setOnEndOfMedia(new Runnable() {
                public void run() {
                    if (!repeat) {
                        stopRequested = true;
                        atEndOfMedia = true;
                    }
                }
            });
            mp.setCycleCount(repeat ? MediaPlayer.INDEFINITE : 1);

            // Time label
            Label timeLabel = LabelBuilder.create()
                    .text("Time")
                    .minWidth(Control.USE_PREF_SIZE)
                    .textFill(Color.WHITE)
                    .build();
            mediaTopBar.getChildren().add(timeLabel);
            
            // Time slider
            timeSlider = SliderBuilder.create()
                    .id("media-slider")
                    .minWidth(240)
                    .maxWidth(Double.MAX_VALUE)
                    .build();
            timeSlider.valueProperty().addListener(new InvalidationListener() {
                public void invalidated(Observable ov) {
                    if (timeSlider.isValueChanging()) {
                        // multiply duration by percentage calculated by slider position
                        if (duration != null) {
                            mp.seek(duration.multiply(timeSlider.getValue() / 100.0));
                        }
                        updateValues();

                    }
                }
            });
            HBox.setHgrow(timeSlider, Priority.ALWAYS);
            mediaTopBar.getChildren().add(timeSlider);
            
            // Play label
            playTime = LabelBuilder.create()
                    .prefWidth(130)
                    .minWidth(50)
                    .textFill(Color.WHITE)
                    .build();
            mediaTopBar.getChildren().add(playTime);
            
            // Volume label
            Label volumeLabel = LabelBuilder.create()
                    .text("Vol")
                    .textFill(Color.WHITE)
                    .minWidth(Control.USE_PREF_SIZE)
                    .build();
            mediaTopBar.getChildren().add(volumeLabel);
            
            // Volume slider
            volumeSlider = SliderBuilder.create()
                    .id("media-slider")
                    .prefWidth(120)
                    .maxWidth(Region.USE_PREF_SIZE)
                    .minWidth(30)
                    .build();
            volumeSlider.valueProperty().addListener(new InvalidationListener() {
                public void invalidated(Observable ov) {
                }
            });
            volumeSlider.valueProperty().addListener(new ChangeListener<Number>() {
                @Override
                public void changed(ObservableValue<? extends Number> observable, Number oldValue, Number newValue) {
                    if (volumeSlider.isValueChanging()) {
                        mp.setVolume(volumeSlider.getValue() / 100.0);
                    }
                }
            });
            mediaTopBar.getChildren().add(volumeSlider);
            
            setTop(mediaTopBar);
            
            final EventHandler<ActionEvent> backAction = new EventHandler<ActionEvent>() {
                public void handle(ActionEvent e) {
                    mp.seek(Duration.ZERO);
                }
            };
            final EventHandler<ActionEvent> stopAction = new EventHandler<ActionEvent>() {
                public void handle(ActionEvent e) {
                    mp.stop();
                }
            };
            final EventHandler<ActionEvent> playAction = new EventHandler<ActionEvent>() {
                public void handle(ActionEvent e) {
                    mp.play();
                }
            };
            final EventHandler<ActionEvent> pauseAction = new EventHandler<ActionEvent>() {
                public void handle(ActionEvent e) {
                    mp.pause();
                }
            };
            final EventHandler<ActionEvent> forwardAction = new EventHandler<ActionEvent>() {
                public void handle(ActionEvent e) {
                    Duration currentTime = mp.getCurrentTime();
                    mp.seek(Duration.seconds(currentTime.toSeconds() + 5.0));
                }
            };

            mediaBottomBar = HBoxBuilder.create()
                    .id("bottom")
                    .spacing(0)
                    .alignment(Pos.CENTER)
                    .children(
                        ButtonBuilder.create()
                            .id("back-button")
                            .text("Back")
                            .onAction(backAction)
                            .build(),
                        ButtonBuilder.create()
                            .id("stop-button")
                            .text("Stop")
                            .onAction(stopAction)
                            .build(),
                        ButtonBuilder.create()
                            .id("play-button")
                            .text("Play")
                            .onAction(playAction)
                            .build(),
                        ButtonBuilder.create()
                            .id("pause-button")
                            .text("Pause")
                            .onAction(pauseAction)
                            .build(),
                        ButtonBuilder.create()
                            .id("forward-button")
                            .text("Forward")
                            .onAction(forwardAction)
                            .build()
                     )
                    .build();
            
            setBottom(mediaBottomBar);
        }

        protected void updateValues() {
            if (playTime != null && timeSlider != null && volumeSlider != null && duration != null) {
                Platform.runLater(new Runnable() {
                    public void run() {
                        Duration currentTime = mp.getCurrentTime();
                        playTime.setText(formatTime(currentTime, duration));
                        timeSlider.setDisable(duration.isUnknown());
                        if (!timeSlider.isDisabled() && duration.greaterThan(Duration.ZERO) && !timeSlider.isValueChanging()) {
                            timeSlider.setValue(currentTime.divide(duration).toMillis() * 100.0);
                        }
                        if (!volumeSlider.isValueChanging()) {
                            volumeSlider.setValue((int) Math.round(mp.getVolume() * 100));
                        }
                    }
                });
            }
        }

        private static String formatTime(Duration elapsed, Duration duration) {
            int intElapsed = (int)Math.floor(elapsed.toSeconds());
            int elapsedHours = intElapsed / (60 * 60);
            if (elapsedHours > 0) {
                intElapsed -= elapsedHours * 60 * 60;
            }
            int elapsedMinutes = intElapsed / 60;
            int elapsedSeconds = intElapsed - elapsedHours * 60 * 60 - elapsedMinutes * 60;

            if (duration.greaterThan(Duration.ZERO)) {
                int intDuration = (int)Math.floor(duration.toSeconds());
                int durationHours = intDuration / (60 * 60);
                if (durationHours > 0) {
                    intDuration -= durationHours * 60 * 60;
                }
                int durationMinutes = intDuration / 60;
                int durationSeconds = intDuration - durationHours * 60 * 60 - durationMinutes * 60;

                if (durationHours > 0) {
                    return String.format("%d:%02d:%02d",
                                         elapsedHours, elapsedMinutes, elapsedSeconds);
                } else {
                    return String.format("%02d:%02d",
                                         elapsedMinutes, elapsedSeconds);
                }
            } else {
                if (elapsedHours > 0) {
                    return String.format("%d:%02d:%02d",
                                         elapsedHours, elapsedMinutes, elapsedSeconds);
                } else {
                    return String.format("%02d:%02d",
                                         elapsedMinutes, elapsedSeconds);
                }
            }
        }
    }

    @Override public void start(Stage primaryStage) throws Exception {
        init(primaryStage);
        primaryStage.show();
        play();
    }
    public static void main(String[] args) { launch(args); }
}

view source
print ?

转载于:https://my.oschina.net/seamanmei/blog/56006

weixin_34419321
关注
【视频播放器】JavaFX实现视频播放器
小筱在线博客
03-13 4061
对于很多Java开发小伙伴来说，不少童鞋都了解过JavaFX，但介于JavaFX的局限性，可能大多数Java开发者也不是很了解，因而在JavaFX中自然也就缺乏实战经验，但是有时候呢我们也想自己研发一些小程序，比如说前面文章中给大家提到的 图片浏览器 ，或者说音频浏览器、视频浏览器等，那今天小编就带大家走进视频浏览器的编程过程！
javafx实现自定义视频播放器（播放、暂停、选择视频、音量、进度控制等）
c1007857613的专栏
03-30 3478
本节介绍了使用javafx实现自定义视频播放器（播放、暂停、选择视频、音量、进度控制等）
利用javafx实现的一个具有完整功能的播放器
01-15
这是利用sun的javafx实现的具有相对完整功能的多媒体播放器-----相对于网上的“一分钟写出一个javafx播放器”而言。 注意：javafx需要一些运行环境，具体说来是： 1.jdk6update14以上 2.javafx运行包----如果你在命令行敲入javafx提示无法找到javafx之类的错误，那么就是你没有此种运行环境了； 3.如果以上你都没有的话，那么就用NetBeans6.4或以上在工具---插件中选在javafx的插件下载，然后直接编译源代码好了。 4.如果你认为以上比较麻烦的话，那么抱歉了，我还没有办法将一个一体式提供上来，因为太大了。 其他的请运行程序后查看“注意事项”. 如果有任何疑问可以直接发信给我，一旦我发现了就会立刻回应.
JAVAFX实现多媒体播放器
fenyudelushang的博客
10-21 3179
使用JAVAFX做的视频播放器，实现了视频播放器的基本功能，音量调节，播放进度控制，播放速率调节，播放暂停，视频切换等功能，下面是代码实现。 public class VedioPlayer extends Application{ private ListView<String> listview = new ListView<>(); private DirectoryChooser fileChooser = new DirectoryChooser(); pri
【多媒体】Java实现MP4和MP3音视频播放器【JavaFX】【音视频播放】
weixin_42369079的博客
06-30 945
JavaFX是一个用于创建富客户端应用程序的GUI框架，它提供了丰富的图形、多媒体和动画功能。在JavaFX中，我们可以使用简洁的代码来实现视频播放功能。
javafx 2.2的 api
10-16
javafx 2.2的 api,chm版本的，英文版的
JavaFX.zip_JavaFX利用Vlc播放视频_JavaFX播放视频_believed75v_javaFx VLC_jav
07-15
JavaFx做界面VLC做视频处理，请看源码
javaFx使用vlc播放器播放流媒体
Jhone_csdn的专栏
07-10 2886
vlc是一个很不错的视频播放器 下载地址 https://www.videolan.org/ 如何测试流媒体链接？ 如何在javaFx项目中集成vlc播放器？ https://github.com/caprica 1、导入依赖jar <dependency> <groupId>uk.co.caprica</groupId> <artifactId>vlcj-javafx</artifactId
基于Java的Javafx在线音乐播放器设计源码
03-28
这是一个基于Java语言开发的Javafx在线音乐播放器，包含42个文件，其中主要文件类型包括25个Java源文件、5个PNG图片文件、3个CSS文件、3个JPG图片文件、1个LICENSE文件、1个Markdown文档、1个XML文件、1个MP3文件、1...
javafx2.2 API文档
02-11
JavaFX 2.2是Oracle公司推出的一个强大的Java图形用户界面（GUI）工具包，用于构建桌面、移动和Web应用程序。这个API文档是开发者在使用JavaFX 2.2进行开发时的重要参考资料，包含了所有类、接口、枚举和注解的详细...
JavaFX播放视频(flv)例子
12-16
一个JAVAFX播放视频的简单例子，希望对初学者有帮助
java 工具包 h264转码MP4 支持html5播放格式
11-30
h264转码MP4 支持html5播放格式 示例代码： H264TrackImpl h264TrackImpl = new H264TrackImpl(new FileDataSourceImpl("C://a.264")); Movie movie = new Movie(); movie.addTrack(h264TrackImpl); Container mp4f = new DefaultMp4Builder().build(movie); FileChannel fChannel = new FileOutputStream(new File("C://a.mp4")).getChannel(); mp4f.writeContainer(fChannel); fChannel.close();
java视频播放器
12-13
用java开发的视频播放器
用JAVA写的视频播放器
11-24
一款用JAVA写的视频播放器，希望对大家有用
Java写的视频播放代码.rar
07-10
Java写的视频播放代码，可实现URL播放，先得到文件的URL地址，然后设置窗口大小和外观、初始化播放器、取得媒体组件、完成预取媒体数据后，开始播放媒体、如果媒体播放完毕，重新设置媒体时间并停止媒体播放器。
java 流媒体播放mp4
最新发布
weixin_41180683的博客
07-13 68
使用Java播放mp4流媒体 在现代的互联网时代，流媒体已经成为人们获取视频和音频内容的主要方式之一。而在Java开发中，如果我们需要实现播放mp4格式的流媒体，我们可以利用Java中的一些库来实现这个功能。本文将介绍如何使用Java来播放mp4流媒体，并提供相关的代码示例。 1. 使用JavaFX播放mp4 JavaFX...
java怎么播放mp4,如何在Java Swing应用程序中播放MP4视频
weixin_39821189的博客
02-13 988
Does anyone know any way I can play an .mp4 video file in a JPanel?I have tried JMF with .avi file but found no success and now I'm baffled and frustrated at how such a simple task of playing a video ...
JavaFx之播放MP4（二十七）
凌康的博客
08-15 611
JavaFX 视频和音频支持，由 JavaFX 媒体类 Media、MediaPlayer、MediaView 和 AudioClip 提供。
java能不能播放mp4,如何使用vlcj在JAVA（swing）jframe中播放mp4视频？还有其他方法可以在JAVA中播放mp4吗？...
weixin_33218490的博客
02-13 415
I want to play video file in JAVA(java swing).I have used JMF(java media framework). But it support .mpg format only.I want to play .mp4 format video file.How to do this?I could play mpg video using t...
javafx播放mp4
01-29
在JavaFX中播放MP4视频可以通过使用MediaPlayer类来实现。首先，需要引入JavaFX的相关依赖，然后创建一个MediaPlayer对象并指定要播放的视频文件路径。接着，可以将MediaPlayer对象添加到MediaView中，然后将...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值