Source Code for Module deefuzzer.player

  1  #!/usr/bin/python 
  2  # -*- coding: utf-8 -*- 
  3  # 
  4  # Copyright (C) 2006-2011 Guillaume Pellerin 
  5   
  6  # <yomguy@parisson.com> 
  7   
  8  # This software is a computer program whose purpose is to stream audio 
  9  # and video data through icecast2 servers. 
 10   
 11  # This software is governed by the CeCILL license under French law and 
 12  # abiding by the rules of distribution of free software. You can use, 
 13  # modify and/ or redistribute the software under the terms of the CeCILL 
 14  # license as circulated by CEA, CNRS and INRIA at the following URL 
 15  # "http://www.cecill.info". 
 16   
 17  # As a counterpart to the access to the source code and  rights to copy, 
 18  # modify and redistribute granted by the license, users are provided only 
 19  # with a limited warranty and the software's author, the holder of the 
 20  # economic rights, and the successive licensors have only limited 
 21  # liability. 
 22   
 23  # In this respect, the user's attention is drawn to the risks associated 
 24  # with loading, using,  modifying and/or developing or reproducing the 
 25  # software by the user in light of its specific status of free software, 
 26  # that may mean that it is complicated to manipulate, and that also 
 27  # therefore means that it is reserved for developers and  experienced 
 28  # professionals having in-depth computer knowledge. Users are therefore 
 29  # encouraged to load and test the software's suitability as regards their 
 30  # requirements in conditions enabling the security of their systems and/or 
 31  # data to be ensured and, more generally, to use and operate it in the 
 32  # same conditions as regards security. 
 33   
 34  # The fact that you are presently reading this means that you have had 
 35  # knowledge of the CeCILL license and that you accept its terms. 
 36   
 37  # Author: Guillaume Pellerin <yomguy@parisson.com> 
 38   
 39  from relay import * 
 40  import time 
 41   
 42   
 43 -class Player: 
 44      """A file streaming iterator""" 
 45   
 46 -    def __init__(self, stream_type='icecast'): 
 47          if stream_type == 'icecast': 
 48              self.main_buffer_size = 0x100000 
 49              self.relay_queue_size = 0x100000 
 50              self.sub_buffer_size = 0x10000 
 51          elif stream_type == 'stream-m': 
 52              self.main_buffer_size = 0x100000 
 53              self.relay_queue_size = 0x100000 
 54              self.sub_buffer_size = 0x10000 
 55   
 56 -    def set_media(self, media): 
 57          self.media = media 
 58   
 59 -    def start_relay(self, url): 
 60          self.url = url 
 61          self.relay = Relay(self.sub_buffer_size, self.relay_queue_size) 
 62          self.relay.set_url(self.url) 
 63          self.relay.open() 
 64          self.relay.start() 
 65          self.queue = self.relay.queue 
 66   
 67 -    def stop_relay(self): 
 68          self.relay.close() 
 69   
 70 -    def file_read_fast(self): 
 71          """Read media and stream data through a generator.""" 
 72          m = open(self.media, 'r') 
 73          while True: 
 74              __main_chunk = m.read(self.sub_buffer_size) 
 75              if not __main_chunk: 
 76                  break 
 77              yield __main_chunk 
 78          m.close() 
 79   
 80 -    def file_read_slow(self): 
 81          """Read a bigger part of the media and stream the little parts 
 82           of the data through a generator""" 
 83          m = open(self.media, 'r') 
 84          while True: 
 85              self.main_chunk = m.read(self.main_buffer_size) 
 86              if not self.main_chunk: 
 87                  break 
 88              i = 0 
 89              while True: 
 90                  start = i * self.sub_buffer_size 
 91                  end = self.sub_buffer_size + (i * self.sub_buffer_size) 
 92                  self.sub_chunk = self.main_chunk[start:end] 
 93                  if not self.sub_chunk: 
 94                      break 
 95                  yield self.sub_chunk 
 96                  i += 1 
 97          self.main_chunk = 0 
 98          self.sub_chunk = 0 
 99          m.close() 
100   
101 -    def relay_read(self): 
102          """Read a distant media through its URL""" 
103          while True: 
104              self.sub_chunk = self.queue.get(self.sub_buffer_size) 
105              if not self.sub_chunk: 
106                  break 
107              yield self.sub_chunk 
108              self.queue.task_done() 
109          self.sub_chunk = 0 
110   
111   
112 -class FileReader: 
113   
114 -    def __init__(self, fp): 
115          self.fp = open(fp, 'r') 
116   
117 -    def read_callback(self, size): 
118          return self.fp.read(size) 
119   
120   
121 -class URLReader: 
122   
123 -    def __init__(self, relay): 
124          self.__relayparam = relay 
125          self.relay = urllib.urlopen(self.__relayparam) 
126          self.rec_mode = 0 
127   
128 -    def set_recorder(self, recorder, mode=1): 
129          self.rec_mode = mode 
130          self.recorder = recorder 
131   
132 -    def read_callback(self, size): 
133          chunk = None 
134   
135          try: 
136              chunk = self.relay.read(size) 
137          except: 
138              while True: 
139                  try: 
140                      self.relay = urllib.urlopen(self.__relayparam) 
141                      chunk = self.relay.read(size) 
142                      break 
143                  except: 
144                      time.sleep(0.5) 
145                      continue 
146   
147          if self.rec_mode == 1 and chunk: 
148              self.recorder.write(chunk) 
149          return chunk 
150