Changes between Initial Version and Version 1 of GEC16Agenda/WiMAX-Tutorial/Streamload/01

Timestamp:

03/17/13 20:13:00 (11 years ago)

Author:

Fraida Fund

Comment:

--

GEC16Agenda/WiMAX-Tutorial/Streamload/01

@@ +1 @@
+== Preparing the streamload experiment ==
+
+To get ready to evaluate how effective this streamloading scheme is, the experimenter implemented a streamload client in Python:
+
+{{{
+#!python
+#!/usr/bin/python
+
+import sys, time, httplib2, math, thread
+from xml.dom.minidom import parse, parseString
+from optparse import OptionParser
+
+class Finished(Exception):
+  def __init__(self, value):
+    self.value = value
+  def __str__(self):
+    return repr(self.value)
+
+class Wait(Exception):
+  def __init__(self, value):
+    self.value = value
+  def __str__(self):
+    return repr(self.value)
+
+class StreamLoad:
+
+  def __init__(self):
+ 
+  def getConfig(self, baseurl, video):
+    self.video = video
+    resp, content = httplib2.Http().request(baseurl + video + ".xml")
+    doc = parseString(content)
+    for node in doc.getElementsByTagName('video'):
+     self.buf = int(node.attributes["buffer"].value)
+     self.chunks = int(node.attributes["chunks"].value)
+     self.layers = int(node.attributes["layers"].value)
+     self.urlbase = str(baseurl) + str(node.attributes["url"].value)
+     self.chunktime = float(node.attributes["chunktime"].value)
+
+  def player(self):
+    startbuf = 0
+    self.played = 0
+    start = self.starttime
+    while self.played<self.chunks:
+      thistime = time.time()
+      if thistime-start >= self.chunktime and self.downloaded[0]>self.played:
+        maxlayer = -1
+        for i in range(self.layers):
+          if self.downloaded[i]>=self.played+1:
+            maxlayer = i
+        self.played+=1
+        start = thistime
+      time.sleep(0.001)
+  
+
+  def start(self, window, sl):
+    self.sl=sl
+    if self.sl:
+      self.window = int(window)
+    else:
+      self.window = int(self.buf)
+    
+    self.downloaded = {}
+    for i in range(self.layers):
+      self.downloaded[i] = 0
+    self.played = 0
+    self.starttime = 0
+    self.getNextPiece()
+    self.starttime = time.time()
+    self.t = thread.start_new_thread(self.player,())
+
+    while True:
+      try:
+        self.getNextPiece()
+      except Wait:
+        pass
+
+  def nextUp(self):
+    # Return chunk 1, layer 0 if we haven't downloaded anything yet
+    if self.starttime == 0:
+      return(1,0)
+    base_chunks_played = self.played
+    if base_chunks_played == self.chunks:
+      raise Finished("all done here")
+    # Download base layer if we are allowed to
+    if (self.downloaded[0] - base_chunks_played) < self.buf and (self.downloaded[0] + 1) <= self.chunks:
+      return (self.downloaded[0]+1,0)
+    else:
+      for i in range(self.layers-1):
+        i = i+1
+        tmp = max(self.downloaded[i],base_chunks_played+1)
+        # If it's in the window and not past the end of the video, download it
+        if tmp - base_chunks_played <= self.window and tmp + 1 <= self.chunks:
+          return (tmp + 1,i)
+      # After all subchunks in the quality windows are downloaded, request one chunk at a time, lower layers first
+      for i in range(self.layers-1):
+        i = i + 1
+        # If I am the highest layer and I have less than the layer beneath me, get the next chunk in my layer
+        if self.sl and i == self.layers-1 and self.downloaded[i] <= self.downloaded[i-1] and self.downloaded[i]+1<=self.chunks:
+          return (self.downloaded[i]+1,i)
+        # Otherwise, if I have less than or the same as the layer above me, download the next chunk
+        if self.sl and i < self.layers-1 and self.downloaded[i] <= self.downloaded[i+1] and self.downloaded[i]+1<=self.chunks:
+          return (self.downloaded[i]+1,i)
+    raise Wait("Nothing to do")
+
+
+
+  def getNextPiece(self):
+    try:
+      (chunk, layer) = self.nextUp()
+    except Wait:
+      return
+    nxt = "chunk" + str(chunk) + "_" + str(layer) + ".264"
+    try:
+      resp, content = httplib2.Http().request(self.urlbase + nxt)
+    except:
+      print "Error downloading file"
+    if chunk > self.played or chunk==self.chunks:
+      try:
+        with open(nxt ,'wb') as f:
+          f.write(content)
+          f.close()
+          self.lastpiecetime = time.time()
+      except:
+        return
+      self.downloaded[layer] = chunk
+
+
+if __name__ == "__main__":
+
+  parser = OptionParser()
+  parser.add_option("-u", "--url", dest="url",
+                    help="URL of video source")
+  parser.add_option("-v", "--video", dest="video",
+                    help="Name of video")
+  parser.add_option("-w", "--window", dest="window", default="5",
+                    help="Download window for enhancement layers")
+  parser.add_option("-s", "--streamload", dest = "sl", default="True",
+                    help="Download in streamload mode")
+
+  (options, args) = parser.parse_args()
+
+  x = StreamLoad()
+  x.getConfig(options.url,options.video)
+  try:
+    if options.sl == "True":
+      x.start(int(options.window),True)
+    else:
+      x.start(int(options.window),False)
+  except Finished:
+    sys.exit(0)
+}}}