Examples of DiskManagerFileInfo


Examples of org.gudy.azureus2.plugins.disk.DiskManagerFileInfo

        final long stream_start = SystemTime.getMonotonousTime();
       
        final Download download = PluginCoreUtils.wrap( dm );
       
        final DiskManagerFileInfo file = download.getDiskManagerFileInfo( file_index );
               
        PluginInterface emp_pi = checkPlugin( "azemp", "media player" );

        checkPlugin( "vuzexcode", "media analyser" );

        Class<?> epwClass = emp_pi.getPlugin().getClass().getClassLoader().loadClass( "com.azureus.plugins.azemp.ui.swt.emp.EmbeddedPlayerWindowSWT" );
       
        Method method = epwClass.getMethod( "prepareWindow", new Class[] { String.class });
       
        final Object player = method.invoke(null, new Object[] { file.getFile( true ).getName() });
     
        final Method buffering_method  = player.getClass().getMethod( "bufferingPlayback", new Class[] { Map.class });
        final Method is_active_method  = player.getClass().getMethod( "isActive", new Class[] {});

        final StreamManagerDownloadListener original_listener = listener;
       
        listener =
          new StreamManagerDownloadListener()
          {
            public void
            updateActivity(
              String    str )
            {
              original_listener.updateActivity(str);
            }
           
            public void
            updateStats(
              int      secs_until_playable,
              int      buffer_secs,
              long    buffer_bytes,
              int      target_buffer_secs )
            {
              original_listener.updateStats(secs_until_playable, buffer_secs, buffer_bytes, target_buffer_secs);
            }
           
            public void
            ready()
            {
              original_listener.ready();
            }
           
            public void
            failed(
              Throwable   error )
            {
              try{
                original_listener.failed(error);
               
                Map<String,Object> b_map = new HashMap<String,Object>();
               
                b_map.put( "state", new Integer( 3 ));
                b_map.put( "msg", Debug.getNestedExceptionMessage( error ));
               
                try{
                  buffering_method.invoke(player, new Object[] { b_map });
 
                }catch( Throwable e ){
                 
                  Debug.out( e );
                }
              }finally{
               
                cancel();
              }
            }
          };
       
        Map<String,Map<String,Object>>  map = (Map<String,Map<String,Object>>)download.getMapAttribute( mi_ta );
       
        Long  l_duration     = null;
        Long  l_video_width   = null;
        Long  l_video_height   = null;
       
        if ( map != null ){
         
          Map<String,Object> file_map = map.get( String.valueOf( file_index ));
         
          if ( file_map != null ){
           
            l_duration     = (Long)file_map.get( "duration" );
            l_video_width   = (Long)file_map.get( "video_width" );
            l_video_height   = (Long)file_map.get( "video_height" );
          }
        }
       
        final long duration;
        long video_width;
        long video_height;
       
        if ( l_duration == null ){
           
          active_edm.prepareForProgressiveMode( true );
         
          try{
            DeviceManager dm = DeviceManagerFactory.getSingleton();
           
            TranscodeManager tm = dm.getTranscodeManager();
           
            DeviceMediaRenderer dmr =
              (DeviceMediaRenderer)dm.addVirtualDevice(
                Device.DT_MEDIA_RENDERER,
                "18a0b53a-a466-6795-1d0f-cf38c830ca0e",
                "generic",
                "Media Analyser" );
 
            dmr.setHidden(true);
 
            TranscodeQueue queue = tm.getQueue();
           
            TranscodeJob[] jobs = queue.getJobs();
           
            for ( TranscodeJob job: jobs ){
             
              if ( job.getTarget() == dmr ){
               
                job.removeForce();
              }
            }
           
            TranscodeProfile[] profiles = dmr.getTranscodeProfiles();
           
            TranscodeProfile profile = null;
           
            for (TranscodeProfile p : profiles) {
             
              if ( p.getName().equals( "Generic MP4" )){
               
                profile = p;
 
                break;
              }
            }
           
            if ( profile == null ){
             
              throw( new Exception( "Analyser transcode profile not found" ));
            }
           
            listener.updateActivity( "Analysing media" );
           
            final Map<String,Object> b_map = new HashMap<String,Object>();
           
            b_map.put( "state", new Integer( 1 ));
            b_map.put( "msg", MessageText.getString( "stream.analysing.media" ));
           
            buffering_method.invoke(player, new Object[] { b_map });

            final TranscodeJob tj = queue.add( dmr, profile, file, true );
                     
            try{
              final AESemaphore sem = new AESemaphore( "analyserWait" );

              synchronized( StreamManager.this ){
               
                if ( cancelled ){
                 
                  throw( new Exception( "Cancelled" ));
                }
               
                active_sem  = sem;
                active_job   = tj;
              }
               
              final long[] properties = new long[3];
             
              final Throwable[] error = { null };
             
              tj.analyseNow(
                new TranscodeAnalysisListener()
                {
                  public void
                  analysisComplete(
                    TranscodeJob          file,
                    TranscodeProviderAnalysis    analysis )
                  {
                    try{                     
                      properties[0] = analysis.getLongProperty( TranscodeProviderAnalysis.PT_DURATION_MILLIS );
                      properties[1] = analysis.getLongProperty( TranscodeProviderAnalysis.PT_VIDEO_WIDTH );
                      properties[2] = analysis.getLongProperty( TranscodeProviderAnalysis.PT_VIDEO_HEIGHT );
                     
                      tj.removeForce();
                     
                    }finally{
                     
                      sem.releaseForever();
                    }
                  }
                 
                  public void
                  analysisFailed(
                    TranscodeJob    file,
                    TranscodeException  e )
                  {
                    try{
                      error[0] = e;
                   
                      tj.removeForce();
                     
                    }finally{
                     
                      sem.releaseForever();
                    }
                  }
                });
             
              new AEThread2( "SM:anmon" )
                {
                  public void
                  run()
                  {
                    boolean  last_preview_mode = preview_mode;
                   
                    while( !sem.isReleasedForever() && !cancelled ){
                     
                      if ( !sem.reserve( 250 )){
                     
                        if ( cancelled ){
                         
                          return;
                        }
                         
                        try{
                          Boolean b = (Boolean)is_active_method.invoke( player, new Object[0] );
                         
                          if ( !b ){
                           
                            cancel();
                           
                            break;
                          }
                        }catch( Throwable e ){ 
                        }
                       
                        if ( last_preview_mode != preview_mode ){
                         
                          last_preview_mode = preview_mode;
                         
                          b_map.put( "msg", MessageText.getString( last_preview_mode?"stream.analysing.media.preview":"stream.analysing.media" ));

                        }
                        DownloadStats stats = download.getStats();
                       
                        b_map.put( "dl_rate", stats.getDownloadAverage());
                        b_map.put( "dl_size", stats.getDownloaded());
                        b_map.put( "dl_time", SystemTime.getMonotonousTime() - stream_start );
                       
                        try{
                          buffering_method.invoke(player, new Object[] { b_map });

                        }catch( Throwable e ){
                         
                        }
                      }
                    }
                  }
                }.start();
               
              sem.reserve();
             
              synchronized( StreamManager.this ){
               
                if ( cancelled ){
                   
                  throw( new Exception( "Cancelled" ));
                }
               
                active_job   = null;
                active_sem  = null;
              }
             
              if ( error[0] != null ){
               
                throw( error[0] );
              }
             
              duration     = properties[0];
              video_width    = properties[1];
              video_height  = properties[2];
             
              if ( duration > 0 ){
               
                if ( map == null ){
                 
                  map = new HashMap<String, Map<String,Object>>();
                 
                }else{
                 
                  map = new HashMap<String, Map<String,Object>>( map );
                }
               
                Map<String,Object> file_map = map.get( String.valueOf( file_index ));
               
                if ( file_map == null ){
               
                  file_map = new HashMap<String, Object>();
                 
                  map.put( String.valueOf( file_index ), file_map );
                }
               
                file_map.put( "duration", duration );
                file_map.put( "video_width", video_width );
                file_map.put( "video_height", video_height );
               
                download.setMapAttribute( mi_ta, map );
              }
             
            }catch( Throwable e ){
             
              tj.removeForce();
             
              throw( e );
            }
           
          }catch( Throwable e ){
           
            throw( new Exception( "Media analysis failed", e ));
           
          }finally{
           
          }
        }else{
           
          duration     = l_duration;
          video_width    = l_video_width==null?0:l_video_width;
          video_height  = l_video_height==null?0:l_video_height;
        }
         
        if ( video_width == 0 || video_height == 0){
         
          throw( new Exception( "Media analysis failed - video stream not found" ));
        }
       
        if ( duration == 0 ){
         
          throw( new Exception( "Media analysis failed - duration unknown" ));
        }
       
        listener.updateActivity( "MetaData read: duration=" + TimeFormatter.formatColon( duration/1000) + ", width=" + video_width + ", height=" + video_height );
       
        Method smd_method = player.getClass().getMethod( "setMetaData", new Class[] { Map.class });
       
        Map<String,Object>  md_map = new HashMap<String,Object>();
       
        md_map.put( "duration", duration );
        md_map.put( "width", video_width );
        md_map.put( "height", video_height );
       
        smd_method.invoke( player, new Object[] { md_map });

        final long  bytes_per_sec = file.getLength() / (duration/1000);
     
        long  dl_lim_max     = COConfigurationManager.getIntParameter( "Plugin.azemp.azemp.config.dl_lim_max" ) * 1024L;
        long  dl_lim_extra   = COConfigurationManager.getIntParameter( "Plugin.azemp.azemp.config.dl_lim_extra" ) * 1024L;

        existing_dl_limit = download.getDownloadRateLimitBytesPerSecond();
       
        long  required_limit = Math.max( dl_lim_max, bytes_per_sec + dl_lim_extra );

        if ( required_limit > 0 ){
       
          download.setDownloadRateLimitBytesPerSecond((int)required_limit );
        }
       
        listener.updateActivity( "Average rate=" + DisplayFormatters.formatByteCountToKiBEtcPerSec( bytes_per_sec ) + ", applied dl limit=" + DisplayFormatters.formatByteCountToKiBEtcPerSec( required_limit ));

        synchronized( StreamManager.this ){
         
          if ( cancelled ){
           
            throw( new Exception( "Cancelled" ));
          }
                                                   
          active_edm.setExplicitProgressive( BUFFER_SECS, bytes_per_sec, file_index );
         
          if ( !active_edm.setProgressiveMode( true )){
           
            throw( new Exception( "Failed to set download as progressive" ));
          }
         
          active_edm_activated = true;
        }
       
        new AEThread2( "streamMon" )
        {
         
          public void
          run()
          { 
            final int TIMER_PERIOD     = 250;
            final int PLAY_STATS_PERIOD  = 5000;
            final int PLAY_STATS_TICKS  = PLAY_STATS_PERIOD / TIMER_PERIOD;
           
            final int DL_STARTUP_PERIOD  = 5000;
            final int DL_STARTUP_TICKS  = DL_STARTUP_PERIOD / TIMER_PERIOD;
     
            boolean playback_started   = false;
            boolean  playback_paused    = false;

            boolean  error_reported = false;
           
            try{
              Method start_method     = player.getClass().getMethod( "startPlayback", new Class[] { URL.class });
              Method pause_method     = player.getClass().getMethod( "pausePlayback", new Class[] {});
              Method resume_method     = player.getClass().getMethod( "resumePlayback", new Class[] {});
              Method buffering_method    = player.getClass().getMethod( "bufferingPlayback", new Class[] { Map.class });
              Method play_stats_method  = player.getClass().getMethod( "playStats", new Class[] { Map.class });

              int tick_count = 0;
             
              while( !cancelled ){
                 
                tick_count++;
               
                int dm_state = dm.getState();
               
                boolean complete = file.getLength() == file.getDownloaded();

                if ( !complete ){
                 
                  if (   dm_state == DownloadManager.STATE_ERROR ||
                      dm_state == DownloadManager.STATE_STOPPED ||
                      dm_state == DownloadManager.STATE_QUEUED ){
                   
                    if ( tick_count >= DL_STARTUP_TICKS ){
                   
                      throw( new Exception( "Streaming abandoned, download isn't running" ));
                    }
                  }
 
                  if ( !active_edm.getProgressiveMode()){
                 
                    complete = file.getLength() == file.getDownloaded();
                   
                    if ( !complete ){
                   
                      throw( new Exception( "Streaming mode abandoned for download" ));
                    }
                  }
                }
             
                long[] details = updateETA( active_edm );
               
                int    eta     = (int)details[0];
                int    buffer_secs  = (int)details[1];
                long  buffer    = details[2];
               
                listener.updateStats( eta, buffer_secs, buffer, BUFFER_SECS );

                boolean playable;
               
                int  buffer_to_use = playback_started?BUFFER_MIN_SECS:BUFFER_SECS;
               
                if ( complete ){
                 
                  playable = true;
                 
                }else{
                 
                  playable = buffer_secs > buffer_to_use;
               
                  playable = playable && ( eta <= || (playback_started && !playback_paused ) || preview_mode );
                }
               
                if ( playback_started ){
                 
                  if ( playable ){
                   
                    if ( playback_paused ){
                     
                      listener.updateActivity( "Resuming playback" );
                     
                      resume_method.invoke(player, new Object[] {});

                      playback_paused = false;
                    }
                  }else{
                     
                    if ( !playback_paused ){
                     
                      listener.updateActivity( "Pausing playback to prevent stall" );
                                             
                      pause_method.invoke(player, new Object[] {});
 
                      playback_paused = true;
                    }
                  }
                }else{
                 
                  if ( playable ){
                   
                    listener.ready();
                     
                    start_method.invoke(player, new Object[] { url });
                   
                    playback_started = true;
                  }
                }
             
                if ( playable ){
                 
                  if ( tick_count % PLAY_STATS_TICKS == 0 ){
                     
                    long contiguous_done = active_edm.getContiguousAvailableBytes( active_edm.getPrimaryFile().getIndex(), 0, 0 );
                 
                    Map<String,Object> map = new HashMap<String,Object>();
                   
                    map.put( "buffer_min", new Long( BUFFER_SECS ));
                    map.put( "buffer_secs", new Integer( buffer_secs ));
                    map.put( "buffer_bytes", new Long( buffer ));
                   
                    map.put( "stream_rate", bytes_per_sec );
                   
                    DownloadStats stats = download.getStats();
                   
                    map.put( "dl_rate", stats.getDownloadAverage());
                    map.put( "dl_size", stats.getDownloaded());
                    map.put( "dl_time", SystemTime.getMonotonousTime() - stream_start );
 
                    map.put( "duration", duration );
                    map.put( "file_size", file.getLength());
                    map.put( "cont_done", contiguous_done );
                   
                    play_stats_method.invoke(player, new Object[] { map });
                  }
                }else{
View Full Code Here
TOP
Copyright © 2018 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.