Recherche avancée

Sur d’autres sites (3198)

• Building my own FFmpeg for android in Ubuntu 14.04 LTS (Vitamio)

  16 août 2016, par EduardoUstarez

  I am trying to build FFmpeg because I realized that my app doesn’t work for android 6.0 in x86 devices before that I have published my app with targetsdkversion 23 (It has text relocations) and now I can’t publish my app using targetsdkversion 22 (This is the way that I could fix the problem). So I read a lot about this problem It seems there isn’t a solution. Some people say that I can compile ffmpeg using —disable-asm flag and I can solve the problem. I want to generate a libffmeg.so for vitamio that works on x86 android 6.0.

  I am using

  Ubuntu 14.04 LTS

  Android NDK r12b

  And my example project is Vitamio-5.0.2 from Download

  So I am working on this tutorial

  This is my FFmpeg-Android.sh file

  #!/bin/bash
  
  
  
  export ANDROID_NDK=/home/myuser/Downloads/android-ndk-r12b
  
  
  
  DEST=`pwd`/build/ffmpeg && rm -rf $DEST
  
  SOURCE=`pwd`/ffmpeg
  
  
  
  if [ -d ffmpeg ]; then
  
    cd ffmpeg
  
  else
  
    git clone git://source.ffmpeg.org/ffmpeg.git ffmpeg
  
    cd ffmpeg
  
  fi
  
  
  
  git reset --hard
  
  git clean -f -d
  
  git checkout `cat ../ffmpeg-version`
  
  patch -p1 <../FFmpeg-VPlayer.patch
  
  [ $PIPESTATUS == 0 ] || exit 1
  
  
  
  git log --pretty=format:%H -1 > ../ffmpeg-version
  
  
  
  TOOLCHAIN=$ANDROID_NDK/toolchains/arm-linux-androideabi-4.9/prebuilt/linux-x86
  
  SYSROOT=$ANDROID_NDK/platforms/android-14/arch-arm/
  
  $ANDROID_NDK/build/tools/make-standalone-toolchain.sh --platform=android-14 --install-dir=$TOOLCHAIN
  
  
  
  export PATH=$TOOLCHAIN/bin:$PATH
  
  export CC="ccache arm-linux-androideabi-gcc"
  
  export LD=arm-linux-androideabi-ld
  
  export AR=arm-linux-androideabi-ar
  
  
  
  CFLAGS="-O3 -Wall -mthumb -pipe -fpic -fasm \
  
    -finline-limit=300 -ffast-math \
  
    -fstrict-aliasing -Werror=strict-aliasing \
  
    -fmodulo-sched -fmodulo-sched-allow-regmoves \
  
    -Wno-psabi -Wa,--noexecstack \
  
    -D__ARM_ARCH_5__ -D__ARM_ARCH_5E__ -D__ARM_ARCH_5T__ -D__ARM_ARCH_5TE__ \
  
    -DANDROID -DNDEBUG"
  
  
  
  FFMPEG_FLAGS="--target-os=linux \
  
    --arch=arm \
  
    --enable-cross-compile \
  
    --cross-prefix=arm-linux-androideabi- \
  
    --enable-shared \
  
    --enable-static \
  
    --disable-symver \
  
    --disable-doc \
  
    --disable-ffplay \
  
    --disable-ffmpeg \
  
    --disable-ffprobe \
  
    --disable-ffserver \
  
    --disable-avdevice \
  
    --disable-avfilter \
  
    --disable-encoders \
  
    --disable-muxers \
  
    --disable-filters \
  
    --disable-devices \
  
    --disable-everything \
  
    --enable-protocols  \
  
    --enable-parsers \
  
    --enable-demuxers \
  
    --enable-decoders \
  
    --enable-bsfs \
  
    --enable-network \
  
    --enable-swscale  \
  
    --disable-demuxer=sbg \
  
    --disable-demuxer=dts \
  
    --disable-parser=dca \
  
    --disable-decoder=dca \
  
    --disable-asm \
  
    --enable-version3"
  
  
  
  
  
  for version in neon armv7 vfp armv6; do
  
  
  
    cd $SOURCE
  
  
  
    case $version in
  
      neon)
  
        EXTRA_CFLAGS="-march=armv7-a -mfpu=neon -mfloat-abi=softfp -mvectorize-with-neon-quad"
  
        EXTRA_LDFLAGS="-Wl,--fix-cortex-a8"
  
        ;;
  
      armv7)
  
        EXTRA_CFLAGS="-march=armv7-a -mfpu=vfpv3-d16 -mfloat-abi=softfp"
  
        EXTRA_LDFLAGS="-Wl,--fix-cortex-a8"
  
        ;;
  
      vfp)
  
        EXTRA_CFLAGS="-march=armv6 -mfpu=vfp -mfloat-abi=softfp"
  
        EXTRA_LDFLAGS=""
  
        ;;
  
      armv6)
  
        EXTRA_CFLAGS="-march=armv6"
  
        EXTRA_LDFLAGS=""
  
        ;;
  
      *)
  
        EXTRA_CFLAGS=""
  
        EXTRA_LDFLAGS=""
  
        ;;
  
    esac
  
  
  
    PREFIX="$DEST/$version" && mkdir -p $PREFIX
  
    FFMPEG_FLAGS="$FFMPEG_FLAGS --prefix=$PREFIX"
  
  
  
    ./configure $FFMPEG_FLAGS --extra-cflags="$CFLAGS $EXTRA_CFLAGS" --extra-ldflags="$EXTRA_LDFLAGS" | tee $PREFIX/configuration.txt
  
    cp config.* $PREFIX
  
    [ $PIPESTATUS == 0 ] || exit 1
  
  
  
    make clean
  
    make -j4 || exit 1
  
    make install || exit 1
  
  
  
    rm libavcodec/inverse.o
  
    $CC -lm -lz -shared --sysroot=$SYSROOT -Wl,--no-undefined -Wl,-z,noexecstack $EXTRA_LDFLAGS libavutil/*.o libavutil/arm/*.o libavcodec/*.o libavcodec/arm/*.o libavformat/*.o libswresample/*.o libswscale/*.o -o $PREFIX/libffmpeg.so
  
  
  
    cp $PREFIX/libffmpeg.so $PREFIX/libffmpeg-debug.so
  
    arm-linux-androideabi-strip --strip-unneeded $PREFIX/libffmpeg.so
  
  
  
  done

  https://www.vitamio.org/en/2013/Tutorial_0509/13.html

  The other files are the same as url provides

  Then the result is

  

  I have deleted -Werror=strict-aliasing from CFLAGS and it generates the other .so files less libffmpeg.so

  

  The error is in this code line

  $CC -lm -lz -shared --sysroot=$SYSROOT -Wl,--no-undefined -Wl,-z,noexecstack $EXTRA_LDFLAGS libavutil/*.o libavutil/arm/*.o libavcodec/*.o libavcodec/arm/*.o libavformat/*.o libswresample/*.o libswscale/*.o -o $PREFIX/libffmpeg.so

  I have removed ccache from export CC="ccache arm-linux-androideabi-gcc"
  and I have an error

  

  I have changed —disable-asm to —enable-asm and I have compiled FFmpeg-Android.sh correctly

  

  I copied the libffmpeg.so generated in armv6, armv7, neon and vfp files in my android studio project.

  I don’t know if I copied libffmpeg.so files in the correct place

  armv6 -> arm64-v8a
  
  armv7 -> armeabi-v7a
  
  neon  -> x86

  

  And the result in Android Studio

  I/Vitamio[5.0.2][Player]: Copyright (c) YIXIA (http://yixia.com).
  
                            THIS SOFTWARE (Vitamio) IS WORK OF YIXIA (http://yixia.com)
  
  I/Vitamio[5.0.2][Player]: LOAD FFMPEG START: libffmpeg.so
  
  E/Vitamio[5.0.2][Player]: FIND_NAME_SYM ffmpeg, av_copy_packet
  
  E/Vitamio[5.0.2][Player]: FIND_NAME_SYM ffmpeg, avfilter_register_all
  
  E/Vitamio[5.0.2][Player]: FIND_NAME_SYM ffmpeg, avfilter_uninit
  
  E/Vitamio[5.0.2][Player]: FIND_NAME_SYM ffmpeg, avfilter_get_by_name
  
  E/Vitamio[5.0.2][Player]: FIND_NAME_SYM ffmpeg, avfilter_inout_alloc
  
  E/Vitamio[5.0.2][Player]: FIND_NAME_SYM ffmpeg, avfilter_inout_free
  
  E/Vitamio[5.0.2][Player]: FIND_NAME_SYM ffmpeg, avfilter_graph_alloc
  
  E/Vitamio[5.0.2][Player]: FIND_NAME_SYM ffmpeg, avfilter_graph_create_filter
  
  E/Vitamio[5.0.2][Player]: FIND_NAME_SYM ffmpeg, avfilter_graph_parse
  
  E/Vitamio[5.0.2][Player]: FIND_NAME_SYM ffmpeg, avfilter_graph_parse2
  
  E/Vitamio[5.0.2][Player]: FIND_NAME_SYM ffmpeg, avfilter_graph_parse_ptr
  
  E/Vitamio[5.0.2][Player]: FIND_NAME_SYM ffmpeg, avfilter_graph_config
  
  E/Vitamio[5.0.2][Player]: FIND_NAME_SYM ffmpeg, av_buffersrc_add_frame
  
  E/Vitamio[5.0.2][Player]: FIND_NAME_SYM ffmpeg, av_buffersink_get_buffer_ref
  
  E/Vitamio[5.0.2][Player]: FIND_NAME_SYM ffmpeg, avfilter_unref_bufferp
  
  E/Vitamio[5.0.2][Player]: FIND_NAME_SYM ffmpeg, avfilter_graph_free
  
  E/Vitamio[5.0.2][Player]: FIND_NAME_SYM ffmpeg, av_abuffersink_params_alloc
  
  E/Vitamio[5.0.2][Player]: FIND_NAME_SYM ssl, SSL_shutdown
  
  E/Vitamio[5.0.2][Player]: FIND_NAME_SYM ssl, SSL_free
  
  E/Vitamio[5.0.2][Player]: FIND_NAME_SYM ssl, SSL_CTX_free
  
  E/Vitamio[5.0.2][Player]: FIND_NAME_SYM ssl, SSL_load_error_strings
  
  E/Vitamio[5.0.2][Player]: FIND_NAME_SYM ssl, SSL_library_init
  
  E/Vitamio[5.0.2][Player]: FIND_NAME_SYM ssl, SSL_CTX_new
  
  E/Vitamio[5.0.2][Player]: FIND_NAME_SYM ssl, TLS_client_method
  
  E/Vitamio[5.0.2][Player]: FIND_NAME_SYM ssl, SSL_new
  
  E/Vitamio[5.0.2][Player]: FIND_NAME_SYM ssl, SSL_set_fd
  
  E/Vitamio[5.0.2][Player]: FIND_NAME_SYM ssl, SSL_connect
  
  E/Vitamio[5.0.2][Player]: FIND_NAME_SYM ssl, SSL_read
  
  E/Vitamio[5.0.2][Player]: FIND_NAME_SYM ssl, SSL_write
  
  E/Vitamio[5.0.2][Player]: FIND_NAME_SYM ssl, ERR_print_errors_fp
  
  I/Vitamio[5.0.2][Player]: LOAD FFMPEG END: libffmpeg.so
  
  I/Vitamio[5.0.2][Player]: LOAD VVO START: libvvo.9.so
  
  E/Vitamio[5.0.2][Player]: FIND_NAME_SYM vvo, render_yuv
  
  I/Vitamio[5.0.2][Player]: LOAD VVO END: libvvo.9.so
  
  I/Vitamio[5.0.2][Player]: LOAD VAO START: libvao.0.so
  
  I/Vitamio[5.0.2][Player]: LOAD VAO END: libvao.0.so
  
  I/Vitamio[5.0.2][Player]: VPLAYER INIT BEGIN
  
  I/Vitamio[5.0.2][Player]: Application package name: **.*******.******************.*********
  
  
  
                            --------- beginning of crash
  
  A/libc: Fatal signal 11 (SIGSEGV), code 1, fault addr 0x0 in tid 3334 (ez.**********
  
  Application terminated.

• Decoding and playing audio with ffmpeg and XAudio2 - frequency raito wrong

  12 juillet 2016, par Brent de Carteret

  I’m using ffmpeg to decode audio and output it using the XAudio2 API, it works and plays synced with the video output using the pts. But it’s high pitched (i.e. sounds like chipmunks).

  Setting breakpoints I can see it has sets the correct sample rate from the audio codec in CreateSourceVoice. I’m stumped.

  Any help would be much appreciated.

  #include "DVDAudioDevice.h"
  
  
  
  HANDLE m_hBufferEndEvent;
  
  
  
  CDVDAudio::CDVDAudio()
  
  {
  
      m_pXAudio2 = NULL;
  
      m_pMasteringVoice = NULL;
  
      m_pSourceVoice = NULL;
  
      m_pWfx  = NULL;
  
  
  
      m_VoiceCallback = NULL;
  
  
  
      m_hBufferEndEvent = CreateEvent(NULL, false, false, "Buffer end event");
  
  }
  
  
  
  CDVDAudio::~CDVDAudio()
  
  {
  
      m_pXAudio2 = NULL;
  
      m_pMasteringVoice = NULL;
  
      m_pSourceVoice = NULL;
  
      m_pWfx  = NULL;
  
  
  
      m_VoiceCallback = NULL;
  
  
  
      CloseHandle(m_hBufferEndEvent);
  
      m_hBufferEndEvent = NULL;
  
  }
  
  
  
  bool CDVDAudio::Create(int iChannels, int iBitrate, int iBitsPerSample, bool bPasstrough)
  
  {
  
      CoInitializeEx(NULL, COINIT_MULTITHREADED);
  
  
  
      HRESULT hr = XAudio2Create( &m_pXAudio2, 0, XAUDIO2_DEFAULT_PROCESSOR);
  
  
  
      if (SUCCEEDED(hr))
  
      {
  
          m_pXAudio2->CreateMasteringVoice( &m_pMasteringVoice );
  
      }
  
  
  
      // Create source voice
  
      WAVEFORMATEXTENSIBLE wfx;
  
      memset(&wfx, 0, sizeof(WAVEFORMATEXTENSIBLE));
  
  
  
      wfx.Format.wFormatTag           = WAVE_FORMAT_PCM;
  
      wfx.Format.nSamplesPerSec       = iBitrate;//pFFMpegData->pAudioCodecCtx->sample_rate;//48000 by default
  
      wfx.Format.nChannels            = iChannels;//pFFMpegData->pAudioCodecCtx->channels;
  
      wfx.Format.wBitsPerSample       = 16;
  
      wfx.Format.nBlockAlign          = wfx.Format.nChannels*16/8;
  
      wfx.Format.nAvgBytesPerSec      = wfx.Format.nSamplesPerSec * wfx.Format.nBlockAlign;
  
      wfx.Format.cbSize               = sizeof(WAVEFORMATEXTENSIBLE)-sizeof(WAVEFORMATEX);
  
      wfx.Samples.wValidBitsPerSample = wfx.Format.wBitsPerSample;
  
  
  
      if(wfx.Format.nChannels == 1)
  
      {
  
          wfx.dwChannelMask = SPEAKER_MONO;
  
      }
  
      else if(wfx.Format.nChannels == 2)
  
      {
  
          wfx.dwChannelMask = SPEAKER_STEREO;
  
      }
  
      else if(wfx.Format.nChannels == 5)
  
      {
  
          wfx.dwChannelMask = SPEAKER_5POINT1;
  
      }
  
  
  
      wfx.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
  
  
  
      unsigned int flags = 0;//XAUDIO2_VOICE_NOSRC;// | XAUDIO2_VOICE_NOPITCH;
  
  
  
      //Source voice
  
  
  
      m_VoiceCallback = new StreamingVoiceCallback(this);
  
  
  
      hr = m_pXAudio2->CreateSourceVoice(&m_pSourceVoice,(WAVEFORMATEX*)&wfx, 0 , 1.0f, m_VoiceCallback);
  
  
  
      if(!SUCCEEDED(hr))
  
          return false;
  
  
  
      // Start sound
  
      hr = m_pSourceVoice->Start(0);
  
  
  
      if(!SUCCEEDED(hr))
  
          return false;
  
  
  
      return true;
  
  }
  
  
  
  DWORD CDVDAudio::AddPackets(unsigned char* data, DWORD len)
  
  {  
  
          memset(&m_SoundBuffer,0,sizeof(XAUDIO2_BUFFER));
  
  
  
          m_SoundBuffer.AudioBytes = len;
  
          m_SoundBuffer.pAudioData = data;
  
          m_SoundBuffer.pContext = NULL;//(VOID*)data;
  
  
  
          XAUDIO2_VOICE_STATE state;
  
  
  
          while(m_pSourceVoice->GetState( &state ), state.BuffersQueued > 60)
  
          {
  
              WaitForSingleObject( m_hBufferEndEvent, INFINITE );
  
          }
  
  
  
          m_pSourceVoice->SubmitSourceBuffer( &m_SoundBuffer );
  
  
  
      return 0;
  
  }
  
  
  
  void CDVDAudio::Destroy()
  
  {
  
      m_pMasteringVoice->DestroyVoice();
  
      m_pXAudio2->Release();
  
  
  
      m_pSourceVoice->DestroyVoice();
  
  
  
      delete m_VoiceCallback;
  
      m_VoiceCallback = NULL;
  
  }

  #include "DVDAudioCodecFFmpeg.h"
  
  #include "Log.h"
  
  
  
  CDVDAudioCodecFFmpeg::CDVDAudioCodecFFmpeg() : CDVDAudioCodec()
  
  {
  
      m_iBufferSize = 0;
  
      m_pCodecContext = NULL;
  
      m_bOpenedCodec = false;
  
  }
  
  
  
  CDVDAudioCodecFFmpeg::~CDVDAudioCodecFFmpeg()
  
  {
  
      Dispose();
  
  }
  
  
  
  bool CDVDAudioCodecFFmpeg::Open(AVCodecID codecID, int iChannels, int iSampleRate)
  
  {
  
      AVCodec* pCodec;
  
      m_bOpenedCodec = false;
  
  
  
      av_register_all();
  
  
  
      pCodec = avcodec_find_decoder(codecID);
  
  
  
      m_pCodecContext = avcodec_alloc_context3(pCodec);//avcodec_alloc_context();
  
      avcodec_get_context_defaults3(m_pCodecContext, pCodec);
  
  
  
      if (!pCodec)
  
      {
  
          CLog::Log(LOGERROR, "CDVDAudioCodecFFmpeg::Open() Unable to find codec");
  
          return false;
  
      }
  
  
  
      m_pCodecContext->debug_mv = 0;
  
      m_pCodecContext->debug = 0;
  
      m_pCodecContext->workaround_bugs = 1;
  
  
  
      if (pCodec->capabilities & CODEC_CAP_TRUNCATED)
  
          m_pCodecContext->flags |= CODEC_FLAG_TRUNCATED;
  
  
  
      m_pCodecContext->channels = iChannels;
  
      m_pCodecContext->sample_rate = iSampleRate;
  
      //m_pCodecContext->bits_per_sample = 24;
  
  
  
  /* //FIXME BRENT
  
    if( ExtraData && ExtraSize > 0 )
  
    {
  
      m_pCodecContext->extradata_size = ExtraSize;
  
      m_pCodecContext->extradata = m_dllAvCodec.av_mallocz(ExtraSize + FF_INPUT_BUFFER_PADDING_SIZE);
  
      memcpy(m_pCodecContext->extradata, ExtraData, ExtraSize);
  
    }
  
  */
  
      // set acceleration
  
      //m_pCodecContext->dsp_mask = FF_MM_FORCE | FF_MM_MMX | FF_MM_MMXEXT | FF_MM_SSE; //BRENT
  
  
  
      if (avcodec_open2(m_pCodecContext, pCodec, NULL) < 0)
  
      {
  
          CLog::Log(LOGERROR, "CDVDAudioCodecFFmpeg::Open() Unable to open codec");
  
          Dispose();
  
          return false;
  
      }
  
  
  
      m_bOpenedCodec = true;
  
      return true;
  
  }
  
  
  
  void CDVDAudioCodecFFmpeg::Dispose()
  
  {
  
      if (m_pCodecContext)
  
      {
  
          if (m_bOpenedCodec) avcodec_close(m_pCodecContext);
  
          m_bOpenedCodec = false;
  
          av_free(m_pCodecContext);
  
          m_pCodecContext = NULL;
  
      }
  
      m_iBufferSize = 0;
  
  }
  
  
  
  int CDVDAudioCodecFFmpeg::Decode(BYTE* pData, int iSize)
  
  {
  
      int iBytesUsed;
  
      if (!m_pCodecContext) return -1;
  
  
  
      //Copy into a FFMpeg AVPAcket again
  
      AVPacket packet;
  
      av_init_packet(&packet);
  
  
  
      packet.data=pData;
  
      packet.size=iSize;
  
  
  
      int iOutputSize = AVCODEC_MAX_AUDIO_FRAME_SIZE; //BRENT
  
  
  
      iBytesUsed = avcodec_decode_audio3(m_pCodecContext, (int16_t *)m_buffer, &iOutputSize/*m_iBufferSize*/, &packet);
  
  
  
      m_iBufferSize = iOutputSize;//BRENT
  
  
  
      return iBytesUsed;
  
  }
  
  
  
  int CDVDAudioCodecFFmpeg::GetData(BYTE** dst)
  
  {
  
      *dst = m_buffer;
  
      return m_iBufferSize;
  
  }
  
  
  
  void CDVDAudioCodecFFmpeg::Reset()
  
  {
  
      if (m_pCodecContext) avcodec_flush_buffers(m_pCodecContext);
  
  }
  
  
  
  int CDVDAudioCodecFFmpeg::GetChannels()
  
  {
  
      if (m_pCodecContext) return m_pCodecContext->channels;
  
      return 0;
  
  }
  
  
  
  int CDVDAudioCodecFFmpeg::GetSampleRate()
  
  {
  
      if (m_pCodecContext) return m_pCodecContext->sample_rate;
  
      return 0;
  
  }
  
  
  
  int CDVDAudioCodecFFmpeg::GetBitsPerSample()
  
  {
  
      if (m_pCodecContext) return 16;
  
      return 0;
  
  }
  #include "DVDPlayerAudio.h"
  
  #include "DVDDemuxUtils.h"
  
  #include "Log.h"
  
  
  
  #include 
  
  #include "DVDAudioCodecFFmpeg.h" //FIXME Move to a codec factory!!
  
  
  
  CDVDPlayerAudio::CDVDPlayerAudio(CDVDClock* pClock) : CThread()
  
  {
  
      m_pClock = pClock;
  
      m_pAudioCodec = NULL;
  
      m_bInitializedOutputDevice = false;
  
      m_iSourceChannels = 0;
  
      m_audioClock = 0;
  
  
  
  //  m_currentPTSItem.pts = DVD_NOPTS_VALUE;
  
  //  m_currentPTSItem.timestamp = 0;
  
  
  
      SetSpeed(DVD_PLAYSPEED_NORMAL);
  
  
  
      InitializeCriticalSection(&m_critCodecSection);
  
      m_messageQueue.SetMaxDataSize(10 * 16 * 1024);
  
  //  g_dvdPerformanceCounter.EnableAudioQueue(&m_packetQueue);
  
  }
  
  
  
  CDVDPlayerAudio::~CDVDPlayerAudio()
  
  {
  
  //  g_dvdPerformanceCounter.DisableAudioQueue();
  
  
  
      // close the stream, and don't wait for the audio to be finished
  
      CloseStream(true);
  
      DeleteCriticalSection(&m_critCodecSection);
  
  }
  
  
  
  bool CDVDPlayerAudio::OpenStream( CDemuxStreamAudio *pDemuxStream )                                 
  
  {
  
      // should alway's be NULL!!!!, it will probably crash anyway when deleting m_pAudioCodec here.
  
      if (m_pAudioCodec)
  
      {
  
          CLog::Log(LOGFATAL, "CDVDPlayerAudio::OpenStream() m_pAudioCodec != NULL");
  
          return false;
  
      }
  
  
  
      AVCodecID codecID = pDemuxStream->codec;
  
  
  
      CLog::Log(LOGNOTICE, "Finding audio codec for: %i", codecID);
  
      //m_pAudioCodec = CDVDFactoryCodec::CreateAudioCodec( pDemuxStream ); 
  
      m_pAudioCodec = new CDVDAudioCodecFFmpeg; //FIXME BRENT Codec Factory needed!
  
  
  
      if (!m_pAudioCodec->Open(pDemuxStream->codec, pDemuxStream->iChannels, pDemuxStream->iSampleRate))
  
      {
  
          m_pAudioCodec->Dispose();
  
          delete m_pAudioCodec;
  
          m_pAudioCodec = NULL;
  
          return false;
  
      }
  
  
  
      if( !m_pAudioCodec )
  
      {
  
          CLog::Log(LOGERROR, "Unsupported audio codec");
  
          return false;
  
      }
  
  
  
      m_codec = pDemuxStream->codec;
  
      m_iSourceChannels = pDemuxStream->iChannels;
  
  
  
      m_messageQueue.Init();
  
  
  
      CLog::Log(LOGNOTICE, "Creating audio thread");
  
      Create();
  
  
  
      return true;
  
  }
  
  
  
  void CDVDPlayerAudio::CloseStream(bool bWaitForBuffers)
  
  {
  
      // wait until buffers are empty
  
      if (bWaitForBuffers) m_messageQueue.WaitUntilEmpty();
  
  
  
      // send abort message to the audio queue
  
      m_messageQueue.Abort();
  
  
  
      CLog::Log(LOGNOTICE, "waiting for audio thread to exit");
  
  
  
      // shut down the adio_decode thread and wait for it
  
      StopThread(); // will set this->m_bStop to true
  
      this->WaitForThreadExit(INFINITE);
  
  
  
      // uninit queue
  
      m_messageQueue.End();
  
  
  
      CLog::Log(LOGNOTICE, "Deleting audio codec");
  
      if (m_pAudioCodec)
  
      {
  
          m_pAudioCodec->Dispose();
  
          delete m_pAudioCodec;
  
          m_pAudioCodec = NULL;
  
      }
  
  
  
      // flush any remaining pts values
  
      //FlushPTSQueue(); //FIXME BRENT
  
  }
  
  
  
  void CDVDPlayerAudio::OnStartup()
  
  {
  
      CThread::SetName("CDVDPlayerAudio");
  
      pAudioPacket = NULL;
  
      m_audioClock = 0;
  
      audio_pkt_data = NULL;
  
      audio_pkt_size = 0;
  
  
  
  //  g_dvdPerformanceCounter.EnableAudioDecodePerformance(ThreadHandle());
  
  }
  
  
  
  void CDVDPlayerAudio::Process()
  
  {
  
      CLog::Log(LOGNOTICE, "running thread: CDVDPlayerAudio::Process()");
  
  
  
      int result;
  
  
  
      // silence data
  
      BYTE silence[1024];
  
      memset(silence, 0, 1024);
  
  
  
      DVDAudioFrame audioframe;
  
  
  
      __int64 iClockDiff=0;
  
      while (!m_bStop)
  
      {
  
          //Don't let anybody mess with our global variables
  
          EnterCriticalSection(&m_critCodecSection);
  
          result = DecodeFrame(audioframe, m_speed != DVD_PLAYSPEED_NORMAL); // blocks if no audio is available, but leaves critical section before doing so
  
          LeaveCriticalSection(&m_critCodecSection);
  
  
  
          if( result & DECODE_FLAG_ERROR ) 
  
          {      
  
              CLog::Log(LOGERROR, "CDVDPlayerAudio::Process - Decode Error. Skipping audio frame");
  
              continue;
  
          }
  
  
  
          if( result & DECODE_FLAG_ABORT )
  
          {
  
              CLog::Log(LOGDEBUG, "CDVDPlayerAudio::Process - Abort recieved, exiting thread");
  
              break;
  
          }
  
  
  
          if( result & DECODE_FLAG_DROP ) //FIXME BRENT
  
          {
  
  /*          //frame should be dropped. Don't let audio move ahead of the current time thou
  
              //we need to be able to start playing at any time
  
              //when playing backwords, we try to keep as small buffers as possible
  
  
  
              // set the time at this delay
  
              AddPTSQueue(audioframe.pts, m_dvdAudio.GetDelay());
  
  */
  
              if (m_speed > 0)
  
              {
  
                  __int64 timestamp = m_pClock->GetAbsoluteClock() + (audioframe.duration * DVD_PLAYSPEED_NORMAL) / m_speed;
  
                  while( !m_bStop && timestamp > m_pClock->GetAbsoluteClock() ) Sleep(1);
  
              }
  
              continue;
  
          }
  
  
  
          if( audioframe.size > 0 ) 
  
          {
  
              // we have succesfully decoded an audio frame, openup the audio device if not already done
  
              if (!m_bInitializedOutputDevice)
  
              {
  
                  m_bInitializedOutputDevice = InitializeOutputDevice();
  
              }
  
  
  
              //Add any packets play
  
              m_dvdAudio.AddPackets(audioframe.data, audioframe.size);
  
  
  
              // store the delay for this pts value so we can calculate the current playing
  
              //AddPTSQueue(audioframe.pts, m_dvdAudio.GetDelay() - audioframe.duration);//BRENT
  
          }
  
  
  
          // if we where asked to resync on this packet, do so here
  
          if( result & DECODE_FLAG_RESYNC )
  
          {      
  
              CLog::Log(LOGDEBUG, "CDVDPlayerAudio::Process - Resync recieved.");
  
              //while (!m_bStop && (unsigned int)m_dvdAudio.GetDelay() > audioframe.duration ) Sleep(5); //BRENT
  
              m_pClock->Discontinuity(CLOCK_DISC_NORMAL, audioframe.pts);
  
          }
  
  
  
  #ifdef USEOLDSYNC
  
          //Clock should be calculated after packets have been added as m_audioClock points to the 
  
          //time after they have been played
  
  
  
          const __int64 iCurrDiff = (m_audioClock - m_dvdAudio.GetDelay()) - m_pClock->GetClock();
  
          const __int64 iAvDiff = (iClockDiff + iCurrDiff)/2;
  
  
  
          //Check for discontinuity in the stream, use a moving average to
  
          //eliminate highfreq fluctuations of large packet sizes
  
          if( ABS(iAvDiff) > 5000 ) // sync clock if average diff is bigger than 5 msec 
  
          {
  
              //Wait untill only the new audio frame wich triggered the discontinuity is left
  
              //then set disc state
  
              while (!m_bStop && (unsigned int)m_dvdAudio.GetBytesInBuffer() > audioframe.size ) Sleep(5);
  
  
  
              m_pClock->Discontinuity(CLOCK_DISC_NORMAL, m_audioClock - m_dvdAudio.GetDelay());
  
              CLog::("CDVDPlayer:: Detected Audio Discontinuity, syncing clock. diff was: %I64d, %I64d, av: %I64d", iClockDiff, iCurrDiff, iAvDiff);
  
              iClockDiff = 0;
  
          }
  
          else
  
          {      
  
              //Do gradual adjustments (not working yet)
  
              //m_pClock->AdjustSpeedToMatch(iClock + iAvDiff);
  
              iClockDiff = iCurrDiff;
  
          }
  
  #endif
  
      }
  
  }
  
  
  
  void CDVDPlayerAudio::OnExit()
  
  {
  
      //g_dvdPerformanceCounter.DisableAudioDecodePerformance();
  
  
  
      // destroy audio device
  
      CLog::Log(LOGNOTICE, "Closing audio device");
  
      m_dvdAudio.Destroy();
  
      m_bInitializedOutputDevice = false;
  
  
  
      CLog::Log(LOGNOTICE, "thread end: CDVDPlayerAudio::OnExit()");
  
  }
  
  
  
  // decode one audio frame and returns its uncompressed size
  
  int CDVDPlayerAudio::DecodeFrame(DVDAudioFrame &audioframe, bool bDropPacket)
  
  {
  
      CDVDDemux::DemuxPacket* pPacket = pAudioPacket;
  
      int n=48000*2*16/8, len;
  
  
  
      //Store amount left at this point, and what last pts was
  
      unsigned __int64 first_pkt_pts = 0;
  
      int first_pkt_size = 0; 
  
      int first_pkt_used = 0;
  
      int result = 0;
  
  
  
      // make sure the sent frame is clean
  
      memset(&audioframe, 0, sizeof(DVDAudioFrame));
  
  
  
      if (pPacket)
  
      {
  
          first_pkt_pts = pPacket->pts;
  
          first_pkt_size = pPacket->iSize;
  
          first_pkt_used = first_pkt_size - audio_pkt_size;
  
      }
  
  
  
      for (;;)
  
      {
  
          /* NOTE: the audio packet can contain several frames */
  
          while (audio_pkt_size > 0)
  
          {
  
              len = m_pAudioCodec->Decode(audio_pkt_data, audio_pkt_size);
  
              if (len < 0)
  
              {
  
                  /* if error, we skip the frame */
  
                  audio_pkt_size=0;
  
                  m_pAudioCodec->Reset();
  
                  break;
  
              }
  
  
  
              // fix for fucked up decoders //FIXME BRENT
  
              if( len > audio_pkt_size )
  
              {        
  
                  CLog::Log(LOGERROR, "CDVDPlayerAudio:DecodeFrame - Codec tried to consume more data than available. Potential memory corruption");        
  
                  audio_pkt_size=0;
  
                  m_pAudioCodec->Reset();
  
                  assert(0);
  
              }
  
  
  
              // get decoded data and the size of it
  
              audioframe.size = m_pAudioCodec->GetData(&audioframe.data);
  
  
  
              audio_pkt_data += len;
  
              audio_pkt_size -= len;
  
  
  
              if (audioframe.size <= 0) continue;
  
  
  
              audioframe.pts = m_audioClock;
  
  
  
              // compute duration.
  
              n = m_pAudioCodec->GetChannels() * m_pAudioCodec->GetBitsPerSample() / 8 * m_pAudioCodec->GetSampleRate();
  
              if (n > 0)
  
              {
  
                  // safety check, if channels == 0, n will result in 0, and that will result in a nice devide exception
  
                  audioframe.duration = (unsigned int)(((__int64)audioframe.size * DVD_TIME_BASE) / n);
  
  
  
                  // increase audioclock to after the packet
  
                  m_audioClock += audioframe.duration;
  
              }
  
  
  
              //If we are asked to drop this packet, return a size of zero. then it won't be played
  
              //we currently still decode the audio.. this is needed since we still need to know it's 
  
              //duration to make sure clock is updated correctly.
  
              if( bDropPacket )
  
              {
  
                  result |= DECODE_FLAG_DROP;
  
              }
  
              return result;
  
          }
  
  
  
          // free the current packet
  
          if (pPacket)
  
          {
  
              CDVDDemuxUtils::FreeDemuxPacket(pPacket); //BRENT FIXME
  
              pPacket = NULL;
  
              pAudioPacket = NULL;
  
          }
  
  
  
          if (m_messageQueue.RecievedAbortRequest()) return DECODE_FLAG_ABORT;
  
  
  
          // read next packet and return -1 on error
  
          LeaveCriticalSection(&m_critCodecSection); //Leave here as this might stall a while
  
  
  
          CDVDMsg* pMsg;
  
          MsgQueueReturnCode ret = m_messageQueue.Get(&pMsg, INFINITE);
  
  
  
          EnterCriticalSection(&m_critCodecSection);
  
          if (MSGQ_IS_ERROR(ret) || ret == MSGQ_ABORT) return DECODE_FLAG_ABORT;
  
  
  
          if (pMsg->IsType(CDVDMsg::DEMUXER_PACKET))
  
          {
  
              CDVDMsgDemuxerPacket* pMsgDemuxerPacket = (CDVDMsgDemuxerPacket*)pMsg;
  
              pPacket = pMsgDemuxerPacket->GetPacket();
  
              pMsgDemuxerPacket->m_pPacket = NULL; // XXX, test
  
              pAudioPacket = pPacket;
  
              audio_pkt_data = pPacket->pData;
  
              audio_pkt_size = pPacket->iSize;
  
          }
  
          else
  
          {
  
              // other data is not used here, free if
  
              // msg itself will still be available
  
              pMsg->Release();
  
          }
  
  
  
          // if update the audio clock with the pts
  
          if (pMsg->IsType(CDVDMsg::DEMUXER_PACKET) || pMsg->IsType(CDVDMsg::GENERAL_RESYNC))
  
          {
  
              if (pMsg->IsType(CDVDMsg::GENERAL_RESYNC))
  
              { 
  
                  //player asked us to sync on this package
  
                  CDVDMsgGeneralResync* pMsgGeneralResync = (CDVDMsgGeneralResync*)pMsg;
  
                  result |= DECODE_FLAG_RESYNC;
  
                  m_audioClock = pMsgGeneralResync->GetPts();
  
              }
  
              else if (pPacket->pts != DVD_NOPTS_VALUE) // CDVDMsg::DEMUXER_PACKET, pPacket is already set above
  
              {
  
                  if (first_pkt_size == 0) 
  
                  { 
  
                      //first package
  
                      m_audioClock = pPacket->pts;        
  
                  }
  
                  else if (first_pkt_pts > pPacket->pts)
  
                  { 
  
                      //okey first packet in this continous stream, make sure we use the time here        
  
                      m_audioClock = pPacket->pts;        
  
                  }
  
                  else if((unsigned __int64)m_audioClock < pPacket->pts || (unsigned __int64)m_audioClock > pPacket->pts)
  
                  {
  
                      //crap, moved outsided correct pts
  
                      //Use pts from current packet, untill we find a better value for it.
  
                      //Should be ok after a couple of frames, as soon as it starts clean on a packet
  
                      m_audioClock = pPacket->pts;
  
                  }
  
                  else if(first_pkt_size == first_pkt_used)
  
                  {
  
                      //Nice starting up freshly on the start of a packet, use pts from it
  
                      m_audioClock = pPacket->pts;
  
                  }
  
              }
  
          }
  
          pMsg->Release();
  
      }
  
  }
  
  
  
  void CDVDPlayerAudio::SetSpeed(int speed)
  
  { 
  
      m_speed = speed;
  
  
  
      //if (m_speed == DVD_PLAYSPEED_PAUSE) m_dvdAudio.Pause(); //BRENT FIXME
  
      //else m_dvdAudio.Resume();
  
  }
  
  
  
  bool CDVDPlayerAudio::InitializeOutputDevice()
  
  {
  
      int iChannels = m_pAudioCodec->GetChannels();
  
      int iSampleRate = m_pAudioCodec->GetSampleRate();
  
      int iBitsPerSample = m_pAudioCodec->GetBitsPerSample();
  
      //bool bPasstrough = m_pAudioCodec->NeedPasstrough(); //BRENT
  
  
  
      if (iChannels == 0 || iSampleRate == 0 || iBitsPerSample == 0)
  
      {
  
          CLog::Log(LOGERROR, "Unable to create audio device, (iChannels == 0 || iSampleRate == 0 || iBitsPerSample == 0)");
  
          return false;
  
      }
  
  
  
      CLog::Log(LOGNOTICE, "Creating audio device with codec id: %i, channels: %i, sample rate: %i", m_codec, iChannels, iSampleRate);
  
      if (m_dvdAudio.Create(iChannels, iSampleRate, iBitsPerSample, /*bPasstrough*/0)) // always 16 bit with ffmpeg ? //BRENT Passthrough needed?
  
      {
  
          return true;
  
      }
  
  
  
      CLog::Log(LOGERROR, "Failed Creating audio device with codec id: %i, channels: %i, sample rate: %i", m_codec, iChannels, iSampleRate);
  
      return false;
  
  }

• Cannot get mp4 video to play in JavaFX app

  23 juin 2016, par CelestialCoyote

  I am trying to use the media player in Java FX to play an mp4 video. I am using the example code from the Oracle. Here is the link.

  http://docs.oracle.com/javafx/2/media/simpleplayer.htm

  I am using the same code with the exception that I want to play the video from my computer rather than going to the internet to get it. I also changed the size of the window to match the size of my video. The video was rendered using FFMPEG with the following parameters.

  ffmpeg -y -r 30 -i ’CellCellCell_Trailer_%05d.jpg’ -r 30 -pix_fmt yuv420p -s 512x512 -vcodec libx264 ’CellCellCell.mp4’

  Could not attach the video to post.

  The video plays in Quicktime and VLC without problems. In the Java App it appears to load, but does not start playing. If I move the time slider, it throws an error, otherwise it just sits there and nothing happens. The file is in a folder called ’media’.

  I have tried several mp4 videos, all with the same results. The player opens, but then does nothing. Any help would be appreciated.

  Here is the code for MediaControl.java file. It is unmodified from the Oracle example.

  package embeddedmediaplayer;
  
  
  
  import javafx.application.Platform;
  
  import javafx.beans.InvalidationListener;
  
  import javafx.beans.Observable;
  
  import javafx.event.ActionEvent;
  
  import javafx.event.EventHandler;
  
  import javafx.scene.layout.Priority;
  
  import javafx.scene.layout.Region;
  
  import javafx.geometry.Insets;
  
  import javafx.geometry.Pos;
  
  import javafx.scene.control.Button;
  
  import javafx.scene.control.Label;
  
  import javafx.scene.control.Slider;
  
  import javafx.scene.layout.BorderPane;
  
  import javafx.scene.layout.HBox;
  
  import javafx.scene.layout.Pane;
  
  import javafx.scene.media.MediaPlayer;
  
  import javafx.scene.media.MediaPlayer.Status;
  
  import javafx.scene.media.MediaView;
  
  import javafx.util.Duration;
  
  
  
  public class MediaControl 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 mediaBar;
  
  
  
  public MediaControl(final MediaPlayer mp) {
  
      this.mp = mp;
  
      setStyle("-fx-background-color: #bfc2c7;");
  
      mediaView = new MediaView(mp);
  
      Pane mvPane = new Pane() {
  
      };
  
      mvPane.getChildren().add(mediaView);
  
      mvPane.setStyle("-fx-background-color: black;");
  
      setCenter(mvPane);
  
  
  
      mediaBar = new HBox();
  
      mediaBar.setAlignment(Pos.CENTER);
  
      mediaBar.setPadding(new Insets(5, 10, 5, 10));
  
      BorderPane.setAlignment(mediaBar, Pos.CENTER);
  
  
  
      final Button playButton = new Button(">");
  
  
  
      playButton.setOnAction(new EventHandler<actionevent>() {
  
          public void handle(ActionEvent e) {
  
              Status status = mp.getStatus();
  
  
  
              if (status == Status.UNKNOWN || status == Status.HALTED) {
  
                  // don't do anything in these states
  
                  return;
  
              }
  
  
  
              if (status == Status.PAUSED
  
                      || status == Status.READY
  
                      || status == Status.STOPPED) {
  
                  // rewind the movie if we're sitting at the end
  
                  if (atEndOfMedia) {
  
                      mp.seek(mp.getStartTime());
  
                      atEndOfMedia = false;
  
                  }
  
                  mp.play();
  
              } else {
  
                  mp.pause();
  
              }
  
          }
  
      });
  
      mp.currentTimeProperty().addListener(new InvalidationListener() {
  
          public void invalidated(Observable ov) {
  
              updateValues();
  
          }
  
      });
  
  
  
      mp.setOnPlaying(new Runnable() {
  
          public void run() {
  
              if (stopRequested) {
  
                  mp.pause();
  
                  stopRequested = false;
  
              } else {
  
                  playButton.setText("||");
  
              }
  
          }
  
      });
  
  
  
      mp.setOnPaused(new Runnable() {
  
          public void run() {
  
              System.out.println("onPaused");
  
              playButton.setText(">");
  
          }
  
      });
  
  
  
      mp.setOnReady(new Runnable() {
  
          public void run() {
  
              duration = mp.getMedia().getDuration();
  
              updateValues();
  
          }
  
      });
  
  
  
      mp.setCycleCount(repeat ? MediaPlayer.INDEFINITE : 1);
  
      mp.setOnEndOfMedia(new Runnable() {
  
          public void run() {
  
              if (!repeat) {
  
                  playButton.setText(">");
  
                  stopRequested = true;
  
                  atEndOfMedia = true;
  
              }
  
          }
  
      });
  
  
  
      mediaBar.getChildren().add(playButton);
  
      // Add spacer
  
      Label spacer = new Label("   ");
  
      mediaBar.getChildren().add(spacer);
  
  
  
      // Add Time label
  
      Label timeLabel = new Label("Time: ");
  
      mediaBar.getChildren().add(timeLabel);
  
  
  
      // Add time slider
  
      timeSlider = new Slider();
  
      HBox.setHgrow(timeSlider, Priority.ALWAYS);
  
      timeSlider.setMinWidth(50);
  
      timeSlider.setMaxWidth(Double.MAX_VALUE);
  
      timeSlider.valueProperty().addListener(new InvalidationListener() {
  
          public void invalidated(Observable ov) {
  
              if (timeSlider.isValueChanging()) {
  
                  // multiply duration by percentage calculated by slider position
  
                  mp.seek(duration.multiply(timeSlider.getValue() / 100.0));
  
              }
  
          }
  
      });
  
      mediaBar.getChildren().add(timeSlider);
  
  
  
      // Add Play label
  
      playTime = new Label();
  
      playTime.setPrefWidth(130);
  
      playTime.setMinWidth(50);
  
      mediaBar.getChildren().add(playTime);
  
  
  
      // Add the volume label
  
      Label volumeLabel = new Label("Vol: ");
  
      mediaBar.getChildren().add(volumeLabel);
  
  
  
      // Add Volume slider
  
      volumeSlider = new Slider();
  
      volumeSlider.setPrefWidth(70);
  
      volumeSlider.setMaxWidth(Region.USE_PREF_SIZE);
  
      volumeSlider.setMinWidth(30);
  
      volumeSlider.valueProperty().addListener(new InvalidationListener() {
  
          public void invalidated(Observable ov) {
  
              if (volumeSlider.isValueChanging()) {
  
                  mp.setVolume(volumeSlider.getValue() / 100.0);
  
              }
  
          }
  
      });
  
      mediaBar.getChildren().add(volumeSlider);
  
  
  
      setBottom(mediaBar);
  
  }
  
  
  
  protected void updateValues() {
  
      if (playTime != null &amp;&amp; timeSlider != null &amp;&amp; volumeSlider != null) {
  
          Platform.runLater(new Runnable() {
  
              public void run() {
  
                  Duration currentTime = mp.getCurrentTime();
  
                  playTime.setText(formatTime(currentTime, duration));
  
                  timeSlider.setDisable(duration.isUnknown());
  
                  if (!timeSlider.isDisabled()
  
                          &amp;&amp; duration.greaterThan(Duration.ZERO)
  
                          &amp;&amp; !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/%d:%02d:%02d",
  
                      elapsedHours, elapsedMinutes, elapsedSeconds,
  
                      durationHours, durationMinutes, durationSeconds);
  
          } else {
  
              return String.format("%02d:%02d/%02d:%02d",
  
                      elapsedMinutes, elapsedSeconds, durationMinutes,
  
                      durationSeconds);
  
          }
  
      } else {
  
          if (elapsedHours > 0) {
  
              return String.format("%d:%02d:%02d", elapsedHours,
  
                      elapsedMinutes, elapsedSeconds);
  
          } else {
  
              return String.format("%02d:%02d", elapsedMinutes,
  
                      elapsedSeconds);
  
          }
  
      }
  
  }
  
  }
  
  </actionevent>

  Here is the code for the EmbeddedMediaPlayer.java file. Only modifications are the file to be played and the size of the window.

  package embeddedmediaplayer;
  
  
  
  import javafx.application.Application;
  
  import javafx.scene.Group;
  
  import javafx.scene.Scene;
  
  import javafx.scene.media.Media;
  
  import javafx.scene.media.MediaPlayer;
  
  import javafx.scene.media.MediaView;
  
  import javafx.scene.Scene;
  
  import javafx.stage.Stage;
  
  
  
  public class EmbeddedMediaPlayer extends Application {
  
  
  
  //    private static final String MEDIA_URL =
  
  //            "http://download.oracle.com/otndocs/products/javafx/oow2010-  2.flv";
  
  
  
  private static final String MEDIA_URL =
  
          "file:./media/CellCellCell.mp4";
  
  
  
  @Override
  
  public void start(Stage primaryStage) {
  
      primaryStage.setTitle("Embedded Media Player");
  
      Group root = new Group();
  
      Scene scene = new Scene(root, 512, 512);
  
  
  
      // create media player
  
      Media media = new Media (MEDIA_URL);
  
      MediaPlayer mediaPlayer = new MediaPlayer(media);
  
      mediaPlayer.setAutoPlay(true);
  
      MediaControl mediaControl = new MediaControl(mediaPlayer);
  
      scene.setRoot(mediaControl);
  
  
  
      primaryStage.setScene(scene);
  
      primaryStage.show();
  
  }
  
  
  
  
  
  public static void main(String[] args) {
  
      launch(args);
  
  }
  
  }