Tvheadend

#!/usr/bin/env python

#

# Copyright (C) 2012 Adam Sutton <[email protected]>

#

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, version 3 of the License.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

#

"""

Support for processing HTSMSG binary format

"""

# ###########################################################################

# Utilities

# ###########################################################################

def int2bin ( i ):

  return chr(i >> 24 & 0xFF) + chr(i >> 16 & 0xFF)\

       + chr(i >> 16 & 0xFF) + chr(i & 0xFF)

def bin2int ( d ):

  return (ord(d[0]) << 24) + (ord(d[1]) << 16)\

       + (ord(d[2]) <<  8) + ord(d[3])

# ###########################################################################

# HTSMSG Binary handler

#

# Note: this will work with the python native types:

#   dict    => HMF_MAP

#   list    => HMF_LIST

#   str     => HMF_STR

#   int     => HMF_S64

#   hmf_bin => HMF_BIN

#

# Note: BIN/STR are both equated to str in python

# ###########################################################################

# HTSMSG types

HMF_MAP  = 1

HMF_S64  = 2

HMF_STR  = 3

HMF_BIN  = 4

HMF_LIST = 5

# Light wrapper for binary type

class hmf_bin(str):

  pass

# Convert python to HTSMSG type

def hmf_type ( f ):

  if type(f) == list:

    return HMF_MAP

  elif type(f) == dict:

    return HMF_LIST

  elif type(f) == str:

    return HMF_STR

  elif type(f) == int:

    return HMF_S64

  elif type(f) == hmf_bin:

    return HMF_BIN

  else:

    raise Exception('invalid type')

# Size for field

def _binary_count ( f ):

  ret = 0

  if type(f) in [ str, hmf_bin ]:

    ret = ret + len(f)

  elif type(f) == int:

    while (f):

      ret = ret + 1

      f   = f >> 8

  elif type(f) in [ list, map ]:

    ret = ret + binary_count(f)

  else:

    raise Exception('invalid data type')

  return ret

# Recursively determine size of message

def binary_count ( msg ):

  ret = 0

  lst = type(msg) == list

  for f in msg:

    ret = ret + 6

    if not lst: 

      ret = ret + len(f)

      f   = msg[f]

    ret = ret + _binary_count(f)

  return ret

# Write out field in binary form

def binary_write ( msg ):

  ret = ''

  lst = type(msg) == list

  for f in msg:

    na = ''

    if not lst:

      na = f

      f  = msg[f]

    ret = ret + chr(hmf_type(f))

    ret = ret + chr(len(na) & 0xFF)

    l   = _binary_count(f)

    ret = ret + int2bin(l)

    ret = ret + na

    if type(f) in [ list, dict ]:

      ret = ret + binary_write(f)

    elif type(f) in [ str, hmf_bin ]:

      ret = ret + f

    elif type(f) == int:

      while f:

        ret = ret + chr(f & 0xFF)

        f   = f >> 8

    else:

      raise Exception('invalid type')

  return ret

# Serialize a htsmsg

def serialize ( msg ):

  cnt  = binary_count(msg)

  return int2bin(cnt) + binary_write(msg)

def new_map():

  return {}

def new_list():

  return []

def store_map_item(name, item, store):

  store[name] = item

def store_list_item(name, item, store):

  store.append(item)

# Deserialize an htsmsg

def deserialize0 ( data, create_storage, store_item ):

  msg = create_storage()

  while len(data) > 5:

    typ  = ord(data[0])

    nlen = ord(data[1])

    dlen = bin2int(data[2:6])

    data = data[6:]

    if len < nlen + dlen: raise Exception('not enough data')

    name = data[:nlen]

    data = data[nlen:]

    if typ == HMF_STR:

      item = data[:dlen]

    elif typ == HMF_BIN:

      item = hmf_bin(data[:dlen])

    elif typ == HMF_S64:

      item = 0

      i    = dlen - 1

      while i >= 0:

        item = (item << 8) | ord(data[i])

        i    = i - 1

    elif typ == HMF_MAP:

      item = deserialize0(data[:dlen], new_map, store_map_item)

    elif typ == HMF_LIST:

      item = deserialize0(data[:dlen], new_list, store_list_item)

    else:

      raise Exception('invalid data type %d' % typ)

    store_item(name, item, msg)

    data      = data[dlen:]

  return msg

# Deserialize a series of message

def deserialize ( fp, rec = False ):

  class _deserialize:

    def __init__ ( self, fp, rec = False ):

      self._fp  = fp

      self._rec = rec

    def __iter__ ( self ):

      print '__iter__()'

      return self

    def _read ( self, num ):

      r = None

      if hasattr(self._fp, 'read'):

        r = self._fp.read(num)

      elif hasattr(self._fp, 'recv'):

        r = self._fp.recv(num)

      elif type(self._fp) is list:

        r = self._fp[:num]

        self._fp = self._fp[num:]

      else:

        raise Exception('invalid data type')

      return r

    def next ( self ):

      if not self._fp: raise StopIteration()

      tmp = self._read(4)

      if len(tmp) != 4:

        self._fp = None

        raise StopIteration()

      num  = bin2int(tmp)

      data = ''

      while len(data) < num:

        tmp  = self._read(num - len(data))

        if not tmp:

          raise Exception('failed to read from fp')

        data = data + tmp

      if not self._rec: self._fp = None

      return deserialize0(data, new_map, store_map_item)

  ret = _deserialize(fp, rec)

  if not rec:

    ret = ret.next()

  return ret

# ############################################################################

# Editor Configuration

#

# vim:sts=2:ts=2:sw=2:et

# ############################################################################