               _stats.fragLastKbps = bandwidth;
               _stats.fragMinKbps = Math.min(_stats.fragMinKbps,bandwidth);
               _stats.fragMaxKbps = Math.max(_stats.fragMaxKbps,bandwidth);
-              _stats.autoLevelCappingMin = Math.min(_stats.autoLevelCappingMin,_hls.autoLevelCapping);
-              _stats.autoLevelCappingMax = Math.max(_stats.autoLevelCappingMax,_hls.autoLevelCapping);
               _stats.fragBuffered++;
             } else {
                   _stats.fragMinLatency = _stats.fragMaxLatency = latency;
                   _stats.fragMinKbps = _stats.fragMaxKbps = bandwidth;
                   _stats.fragBuffered = 1;
                   _stats.fragBufferedBytes = 0;
-                  _stats.autoLevelCappingMin = _stats.autoLevelCappingMax = _hls.autoLevelCapping;
                   _sumLatency=0;
                   _sumKbps=0;
             }
             _sumLatency+=latency;
             _sumKbps+=bandwidth;
             _stats.fragBufferedBytes+=metrics.size;
-            _stats.fragAvgLatency = _sumLatency/_stats.fragBuffered;
-            _stats.fragAvgKbps = _sumKbps/_stats.fragBuffered;
-            _stats.autoLevelCappingLast = _hls.autoLevelCapping;
+            _stats.fragAvgLatency = Math.round(_sumLatency/_stats.fragBuffered);
+            _stats.fragAvgKbps = Math.round(_sumKbps/_stats.fragBuffered);
         }
 
         private function _fragmentPlayingHandler(event : HLSEvent) : void {
-          var metrics : HLSPlayMetrics = event.playMetrics;
-          var level : int = metrics.level;
-          var autoLevel : Boolean = metrics.auto_level;
-          if(_stats.levelStart == -1) {
-              _stats.levelStart = level;
-          }
-
-          if(autoLevel) {
-              if(_stats.fragChangedAuto) {
-                _stats.autoLevelMin = Math.min(_stats.autoLevelMin,level);
-                _stats.autoLevelMax = Math.max(_stats.autoLevelMax,level);
-                _stats.fragChangedAuto++;
-                if(_levelLastAuto && level !== _stats.autoLevelLast) {
-                  _stats.autoLevelSwitch++;
-              }
-              } else {
-                _stats.autoLevelMin = _stats.autoLevelMax = level;
-                _stats.autoLevelSwitch = 0;
-                _stats.fragChangedAuto = 1;
-                _sumAutoLevel = 0;
-            }
-            _sumAutoLevel+=level;
-            _stats.autoLevelAvg = _sumAutoLevel/_stats.fragChangedAuto;
-            _stats.autoLevelLast = level;
-            } else {
-              if(_stats.fragChangedManual) {
-                _stats.manualLevelMin = Math.min(_stats.manualLevelMin,level);
-                _stats.manualLevelMax = Math.max(_stats.manualLevelMax,level);
-                _stats.fragChangedManual++;
-                if(!_levelLastAuto && level !== _stats.manualLevelLast) {
-                  _stats.manualLevelSwitch++;
-              }
-              } else {
-                _stats.manualLevelMin = _stats.manualLevelMax = level;
-                _stats.manualLevelSwitch = 0;
-                _stats.fragChangedManual = 1;
-            }
-            _stats.manualLevelLast = level;
+        if(_stats.fragPlaying) {
+            _stats.fragPlaying++;
+        } else {
+            _stats.fragPlaying = 1;
         }
-        _levelLastAuto = autoLevel;
       }
 
       private function _fragmentSkippedHandler(event : HLSEvent) : void {

        }
      }

      private function _fpsDropHandler(event : HLSEvent) : void {
        _stats.fpsDropEvent++;
        _stats.fpsTotalDroppedFrames = _hls.stream.info.droppedFrames;
      }

      private function _fpsDropLevelCappingHandler(event : HLSEvent) : void {
         _stats.fpsDropLevelCappingMin=event.level;
      }

      private function _fpsDropSmoothLevelSwitchHandler(event : HLSEvent) : void {
        _stats.fpsDropSmoothLevelSwitch++;
      }
  }
}

            _hls.removeEventListener(HLSEvent.FRAGMENT_PLAYING, _fragmentPlayingHandler);
            _hls.removeEventListener(HLSEvent.FRAGMENT_SKIPPED,_fragmentSkippedHandler);
            _hls.removeEventListener(HLSEvent.FRAGMENT_LOAD_EMERGENCY_ABORTED,_fragmentLoadEmergencyAbortedHandler);
            _hls.removeEventListener(HLSEvent.MEDIA_TIME, _mediaTimeHandler);
        }

        public function get stats() : Object {
