传输媒体从一个位置到另一个位置 : 媒体 « 图形用户界面 « Java

En
Java
1. 图形用户界面
2. 三维图形动画
3. 高级图形
4. 蚂蚁编译
5. Apache类库
6. 统计图
7. 
8. 集合数据结构
9. 数据类型
10. 数据库JDBC
11. 设计模式
12. 开发相关类
13. EJB3
14. 电子邮件
15. 事件
16. 文件输入输出
17. 游戏
18. 泛型
19. GWT
20. Hibernate
21. 本地化
22. J2EE平台
23. 基于J2ME
24. JDK-6
25. JNDI的LDAP
26. JPA
27. JSP技术
28. JSTL
29. 语言基础知识
30. 网络协议
31. PDF格式RTF格式
32. 映射
33. 常规表达式
34. 脚本
35. 安全
36. Servlets
37. Spring
38. Swing组件
39. 图形用户界面
40. SWT-JFace-Eclipse
41. 线程
42. 应用程序
43. Velocity
44. Web服务SOA
45. 可扩展标记语言
Java 教程
Java » 图形用户界面 » 媒体屏幕截图 
传输媒体从一个位置到另一个位置

/*

Java Media APIs: Cross-Platform Imaging, Media and Visualization
Alejandro Terrazas
Sams, Published November 2002, 
ISBN 0672320940
*/


import javax.media.*;
import javax.media.datasink.*;
import javax.media.protocol.*;

/*******************************************************************************
 * Transfer media from one location to another carrying out the specified
 * transcoding (track formats and content type) at the same time.
 * <p>
 * Users specify a source and destination location, the Formats (to be realised)
 * of the individual tracks, and a ContentDescriptor (content type) for output.
 * <p>
 * A Processor is created to perform and transcoding and its output DataSource
 * is employed to construct a DataSink in order to complete the transfer.
 * <p>
 * The most important method of the class is transfer() as this opens and starts
 * the DataSink. The constructor builds both the Processor (which is starts) and
 * the DataSink.
 * <p>
 * The object keeps track of its own state, which can be queried with the
 * getState() method. Defined constants are FAILED, TRANSLATING, TRANSFERRING,
 * and FINISHED. The process is asychronous: transcoding largish movies can take
 * a long time. The calling code should make allowances for that.
 ******************************************************************************/
public class Location2Location implements ControllerListener {

  /** Output of the Processor: the transcoded media. */
  protected DataSource source;

  /** Sink used to "write" out the transcoded media. */
  protected DataSink sink;

  /** Processor used to transcode the media. */
  protected Processor processor;

  /**
   * Model used in constructing the processor, and which specifies track
   * formats and output content type
   */
  protected ProcessorModel model;

  /** State the object is in. */
  protected int state;

  /** Location that the media will be "written" to. */
  protected MediaLocator sinkLocation;

  /** The rate of translation. */
  protected float translationRate;

  /** Process has failed. */
  public static final int FAILED = 0;

  /**
   * Processor is working but not finished. DataSink is yet to start.
   */
  public static final int TRANSLATING = 1;

  /** DataSink has started but not finished. */
  public static final int TRANSFERRING = 3;

  /** Transcoding and transfer is complete. */
  public static final int FINISHED = 4;

  /** String names for each of the states. More user friendly */
  private static final String[] STATE_NAMES = "Failed""Translating",
      "<UNUSED>""Transferring""Finished" };

  /**
   * Period (in milliseconds) between checks for the blocking transfer method.
   */
  public static final int WAIT_PERIOD = 50;

  /**
   * Wait an "indefinite" period of time for the transfer method to complete.
   * i.e., pass to transfer() if the user wishes to block till the process is
   * complete, regardless of how long it will take.
   */
  public static final int INDEFINITE = Integer.MAX_VALUE;

  /***************************************************************************
   * Construct a transfer/transcode object that transfers media from
   * sourceLocation to destinationLocation, transcoding the tracks as
   * specified by the outputFormats. The output media is to have a content
   * type of outputContainer and the process should (if possible) run at the
   * passed rate.
   **************************************************************************/
  Location2Location(MediaLocator sourceLocation,
      MediaLocator destinationLocation, Format[] outputFormats,
      ContentDescriptor outputContainer, double rate) {

    //////////////////////////////////////////////
    // Construct the processor for the transcoding
    //////////////////////////////////////////////
    state = TRANSLATING;
    sinkLocation = destinationLocation;
    try {
      if (sourceLocation == null)
        model = new ProcessorModel(outputFormats, outputContainer);
      else
        model = new ProcessorModel(sourceLocation, outputFormats,
            outputContainer);
      processor = Manager.createRealizedProcessor(model);
    catch (Exception e) {
      state = FAILED;
      return;
    }

    translationRate = processor.setRate((floatMath.abs(rate));
    processor.addControllerListener(this);

    ////////////////////////////////////////////////////////////
    // Construct the DataSink and employ an anonymous class as
    // a DataSink listener in order that the end of transfer
    // (completion of task) can be detected.
    ///////////////////////////////////////////////////////////
    source = processor.getDataOutput();
    try {
      sink = Manager.createDataSink(source, sinkLocation);
    catch (Exception sinkException) {
      state = FAILED;
      processor.removeControllerListener(this);
      processor.close();
      processor = null;
      return;
    }
    sink.addDataSinkListener(new DataSinkListener() {
      public void dataSinkUpdate(DataSinkEvent e) {
        if (instanceof EndOfStreamEvent) {
          sink.close();
          source.disconnect();
          if (state != FAILED)
            state = FINISHED;
        else if (instanceof DataSinkErrorEvent) {
          if (sink != null)
            sink.close();
          if (source != null)
            source.disconnect();
          state = FAILED;
        }
      }
    });
    // Start the transcoding
    processor.start();
  }

  /***************************************************************************
   * Alternate constructor: source and destination specified as Strings, and
   * no rate provided (hence rate of 1.0)
   **************************************************************************/
  Location2Location(String sourceName, String destinationName,
      Format[] outputFormats, ContentDescriptor outputContainer) {

    this(new MediaLocator(sourceName)new MediaLocator(destinationName),
        outputFormats, outputContainer);
  }

  /***************************************************************************
   * Alternate constructor: No rate specified therefore rate of 1.0
   **************************************************************************/
  Location2Location(MediaLocator sourceLocation,
      MediaLocator destinationLocation, Format[] outputFormats,
      ContentDescriptor outputContainer) {

    this(sourceLocation, destinationLocation, outputFormats,
        outputContainer, 1.0f);
  }

  /***************************************************************************
   * Alternate constructor: source and destination specified as Strings.
   **************************************************************************/
  Location2Location(String sourceName, String destinationName,
      Format[] outputFormats, ContentDescriptor outputContainer,
      double rate) {

    this(new MediaLocator(sourceName)new MediaLocator(destinationName),
        outputFormats, outputContainer, rate);
  }

  /***************************************************************************
   * Respond to events from the Processor performing the transcoding. If its
   * task is completed (end of media) close it down. If there is an error
   * close it down and mark the process as FAILED.
   **************************************************************************/
  public synchronized void controllerUpdate(ControllerEvent e) {

    if (state == FAILED)
      return;

    // Transcoding complete.
    if (instanceof StopEvent) {
      processor.removeControllerListener(this);
      processor.close();
      if (state == TRANSLATING)
        state = TRANSFERRING;
    }
    // Transcoding failed.
    else if (instanceof ControllerErrorEvent) {
      processor.removeControllerListener(this);
      processor.close();
      state = FAILED;
    }
  }

  /***************************************************************************
   * Initiate the transfer through a DataSink to the destination and wait
   * (block) until the process is complete (or failed) or the supplied number
   * of milliseconds timeout has passed. The method returns the total amount
   * of time it blocked.
   **************************************************************************/
  public int transfer(int timeOut) {

    // Can't initiate: Processor already failed to transcode
    ////////////////////////////////////////////////////////
    if (state == FAILED)
      return -1;

    // Start the DataSink
    //////////////////////
    try {
      sink.open();
      sink.start();
    catch (Exception e) {
      state = FAILED;
      return -1;
    }
    if (state == TRANSLATING)
      state = TRANSFERRING;
    if (timeOut <= 0)
      return timeOut;

    // Wait till the process is complete, failed, or the
    // prescribed time has passed.
    /////////////////////////////////////////////////////
    int waited = 0;
    while (state != FAILED && state != FINISHED && waited < timeOut) {
      try {
        Thread.sleep(WAIT_PERIOD);
      catch (InterruptedException ie) {
      }
      waited += WAIT_PERIOD;
    }
    return waited;
  }

  /***************************************************************************
   * Initiate the transfer through a DataSink to the destination but return
   * immediately to the caller.
   **************************************************************************/
  public void transfer() {

    transfer(-1);
  }

  /***************************************************************************
   * Determine the object's current state. Returns one of the class constants.
   **************************************************************************/
  public int getState() {

    return state;
  }

  /***************************************************************************
   * Returns the object's state as a String. A more user friendly version of
   * getState().
   **************************************************************************/
  public String getStateName() {

    return STATE_NAMES[state];
  }

  /***************************************************************************
   * Obtain the rate being used for the process. This is often 1, despite what
   * the user may have supplied as Clocks (hence Processors) don't have to
   * support any other rate than 1 (and will default to that).
   **************************************************************************/
  public float getRate() {

    return translationRate;
  }

  /***************************************************************************
   * Set the time at which media processing will stop. Specification is in
   * media time. This means only the first "when" amount of the media will be
   * transferred.
   **************************************************************************/
  public void setStopTime(Time when) {

    if (processor != null)
      processor.setStopTime(when);
  }

  /***************************************************************************
   * Stop the processing and hence transfer. This gives user control over the
   * duration of a transfer. It could be started with the transfer() call and
   * after a specified period stop() could be called.
   **************************************************************************/
  public void stop() {

    if (processor != null)
      processor.stop();
  }
}

           
       
Related examples in the same category
1. Java媒体:查找组件Java媒体:查找组件
2. 查询配置JMF查询配置JMF
3. Show the Location2Location class in actionShow the Location2Location class in action
4. 捕获音频或视频通过设备连接到PC
5. Choose the media they wish to playChoose the media they wish to play
6. 做音频捕捉
7. 统计信息跟踪构成一个媒体对象
8. 播放媒体对象
9. 播放器:播放媒体对象
10. 播放媒体对象3
11. 列出所有撷取装置目前已知的JMF列出所有撷取装置目前已知的JMF
www.java2java.com | Contact Us
Copyright 2010 - 2030 Java Source and Support. All rights reserved.
All other trademarks are property of their respective owners.