home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2007 September / PCWSEP07.iso / Software / Linux / Linux Mint 3.0 Light / LinuxMint-3.0-Light.iso / casper / filesystem.squashfs / usr / lib / hplip / base / mfpdtf.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2007-04-29  |  8.0 KB  |  292 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.5)
  3.  
  4. import struct
  5. import cStringIO
  6. from g import *
  7. from codes import *
  8. NEW_PAGE = 1
  9. END_PAGE = 2
  10. NEW_DOCUMENT = 4
  11. END_DOCUMENT = 8
  12. END_STREAM = 16
  13. RESERVED_20 = 32
  14. RESERVED_40 = 64
  15. RESERVED_80 = 128
  16. MFPDTF_RASTER_BITMAP = 0
  17. MFPDTF_RASTER_GRAYMAP = 1
  18. MFPDTF_RASTER_MH = 2
  19. MFPDTF_RASTER_MR = 3
  20. MFPDTF_RASTER_MMR = 4
  21. MFPDTF_RASTER_RGB = 5
  22. MFPDTF_RASTER_YCC411 = 6
  23. MFPDTF_RASTER_JPEG = 7
  24. MFPDTF_RASTER_PCL = 8
  25. MFPDTF_RASTER_NOT = 9
  26. DT_UNKNOWN = 0
  27. DT_FAX_IMAGES = 1
  28. DT_SCANNED_IMAGES = 2
  29. DT_DIAL_STRINGS = 3
  30. DT_DEMO_PAGES = 4
  31. DT_SPEED_DIALS = 5
  32. DT_FAX_LOGS = 6
  33. DT_CFG_PARMS = 7
  34. DT_LANG_STRS = 8
  35. DT_JUNK_FAX_CSIDS = 9
  36. DT_REPORT_STRS = 10
  37. DT_FONTS = 11
  38. DT_TTI_BITMAP = 12
  39. DT_COUNTERS = 13
  40. DT_DEF_PARMS = 14
  41. DT_SCAN_OPTIONS = 15
  42. DT_FW_JOB_TABLE = 17
  43. RT_START_PAGE = 0
  44. RT_RASTER = 1
  45. RT_END_PAGE = 2
  46. FIXED_HEADER_SIZE = 8
  47. IMAGE_VARIANT_HEADER_SIZE = 10
  48. DIAL_STRINGS_VARIANT_HEADER_SIZE = 6
  49. FAX_IMAGE_VARIANT_HEADER_SIZE = 74
  50. SOP_RECORD_SIZE = 36
  51. RASTER_RECORD_SIZE = 4
  52. EOP_RECORD_SIZE = 12
  53. DIAL_STRING_RECORD_SIZE = 51
  54. PAGE_FLAG_NEW_PAGE = 1
  55. PAGE_FLAG_END_PAGE = 2
  56. PAGE_FLAG_NEW_DOC = 4
  57. PAGE_FLAG_END_DOC = 8
  58. PAGE_FLAG_END_STREAM = 16
  59. SRC_UNKNOWN = 0
  60. SRC_HOST = 2
  61. SRC_SCANNER = 5
  62. SRC_HOST_THEN_SCANNER = 6
  63. SRC_SCANNER_THEN_HOST = 7
  64. TTI_NONE = 0
  65. TTI_PREPENDED_TO_IMAGE = 1
  66. TTI_OVERLAYED_ON_IMAGE = 2
  67. MAJOR_VER = 2
  68. MINOR_VER = 0
  69.  
  70. def parseFixedHeader(buffer):
  71.     fmt = '<IHBB'
  72.     (block_len, header_len, data_type, page_flags) = struct.unpack(fmt, buffer[:8])
  73.     page_flags = page_flags & 31
  74.     return (block_len, header_len, data_type, page_flags)
  75.  
  76.  
  77. def parseImageVariantHeader(buffer, data_type):
  78.     if data_type == DT_SCANNED_IMAGES:
  79.         fmt = '<BBHHHH'
  80.         (major_ver, minor_ver, src_pages, copies_per_page, zoom, jpeg_q_factor) = struct.unpack(fmt, buffer[:10])
  81.         return (major_ver, minor_ver, src_pages, copies_per_page, zoom, jpeg_q_factor)
  82.     elif data_type == DT_FAX_IMAGES:
  83.         pass
  84.     
  85.  
  86.  
  87. def parseRecord(buffer):
  88.     record_type = struct.unpack('<B', buffer[0])[0]
  89.     if record_type == RT_START_PAGE:
  90.         fmt = '<BBHHHIIIHHIII'
  91.         (id, encoding, page_num, black_ppr, black_bpp, black_rpp, black_hort_dpi, black_vert_dpi, cmy_ppr, cmy_bpp, cmy_rpp, cmy_hort_dpi, cmy_vert_dpi) = struct.unpack(fmt, buffer[:SOP_RECORD_SIZE])
  92.         if not id == record_type:
  93.             raise AssertionError
  94.         return (id, (encoding, page_num, black_ppr, black_bpp, black_rpp, black_hort_dpi, black_vert_dpi, cmy_ppr, cmy_bpp, cmy_rpp, cmy_hort_dpi, cmy_vert_dpi))
  95.     elif record_type == RT_RASTER:
  96.         fmt = '<BBH'
  97.         (id, unused, data_size) = struct.unpack(fmt, buffer[:RASTER_RECORD_SIZE])
  98.         if not id == record_type:
  99.             raise AssertionError
  100.         return (id, (unused, data_size))
  101.     elif record_type == RT_END_PAGE:
  102.         fmt = '<BBBBII'
  103.         (id, unused1, unused2, unused3, black_rows, cmy_rows) = struct.unpack(fmt, buffer[:EOP_RECORD_SIZE])
  104.         if not id == record_type:
  105.             raise AssertionError
  106.         return (id, (unused1, unused2, unused3, black_rows, cmy_rows))
  107.     
  108.     log.error('Error: Invalid record type: %d' % record_type)
  109.     raise Error(ERROR_INTERNAL)
  110.  
  111.  
  112. def readChannelToStream(device, channel_id, stream, single_read = True, callback = None):
  113.     (STATE_END, STATE_FIXED_HEADER, STATE_VARIANT_HEADER, STATE_RECORD) = range(4)
  114.     (state, total_bytes, block_remaining, header_remaining, data_remaining) = (1, 0, 0, 0, 0)
  115.     endScan = False
  116.     while state != STATE_END:
  117.         log.debug('**** State %d ****' % state)
  118.         if state == STATE_FIXED_HEADER:
  119.             if endScan:
  120.                 state = STATE_END
  121.                 break
  122.             
  123.             if data_remaining == 0:
  124.                 (fields, data) = device.readChannel(channel_id)
  125.                 data_remaining = len(data)
  126.                 if callback is not None:
  127.                     endScan = callback()
  128.                 
  129.             
  130.             (block_len, header_len, data_type, page_flags) = parseFixedHeader(data)
  131.             block_remaining = block_len - FIXED_HEADER_SIZE
  132.             header_remaining = header_len - FIXED_HEADER_SIZE
  133.             log.debug('Fixed header: (datalen=%d(0x%x),blocklen=%d(0x%x),headerlen=%d(0x%x),datatype=0x%x,pageflags=0x%x)' % (len(data), len(data), block_len, block_len, header_len, header_len, data_type, page_flags))
  134.             data_remaining -= FIXED_HEADER_SIZE
  135.             data = data[FIXED_HEADER_SIZE:]
  136.             state = STATE_RECORD
  137.             log.debug('Data: data=%d,block=%d,header=%d' % (data_remaining, block_remaining, header_remaining))
  138.             if page_flags & PAGE_FLAG_END_STREAM:
  139.                 state = STATE_END
  140.                 break
  141.             
  142.             if header_remaining > 0:
  143.                 state = STATE_VARIANT_HEADER
  144.             
  145.         header_remaining > 0
  146.         if state == STATE_VARIANT_HEADER:
  147.             if data_type == DT_SCANNED_IMAGES:
  148.                 (major_ver, minor_ver, src_pages, copies_per_page, zoom, jpeg_q_factor) = parseImageVariantHeader(data, data_type)
  149.                 log.debug('Variant header: (major/minor=%d/%d,src_pages=%d,copies_per_page=%d,zoom=%d,jpeg_q_factor=%d' % (major_ver, minor_ver, src_pages, copies_per_page, zoom, jpeg_q_factor))
  150.                 data = data[IMAGE_VARIANT_HEADER_SIZE:]
  151.                 block_remaining -= IMAGE_VARIANT_HEADER_SIZE
  152.                 header_remaining -= IMAGE_VARIANT_HEADER_SIZE
  153.                 data_remaining -= IMAGE_VARIANT_HEADER_SIZE
  154.             elif data_type == DT_FAX_IMAGES:
  155.                 log.error('Unsupported data type')
  156.             else:
  157.                 log.error('Unsupported data type')
  158.             log.debug('Data: data=%d,block=%d,header=%d' % (data_remaining, block_remaining, header_remaining))
  159.             if header_remaining > 0:
  160.                 log.error('Header size error.')
  161.                 state = STATE_END
  162.                 continue
  163.             
  164.             state = STATE_RECORD
  165.             if block_remaining == 0:
  166.                 state = STATE_FIXED_HEADER
  167.                 continue
  168.             continue
  169.             continue
  170.         if state == STATE_RECORD:
  171.             (record_type, record) = parseRecord(data)
  172.             if record_type == RT_START_PAGE:
  173.                 (encoding, page_num, black_ppr, black_bpp, black_rpp, black_hort_dpi, black_vert_dpi, cmy_ppr, cmy_bpp, cmy_rpp, cmy_hort_dpi, cmy_vert_dpi) = record
  174.                 log.debug('Start page record: (encoding=0x%x, page=%d)' % (encoding, page_num))
  175.                 data = data[SOP_RECORD_SIZE:]
  176.                 block_remaining -= SOP_RECORD_SIZE
  177.                 data_remaining -= SOP_RECORD_SIZE
  178.                 if block_remaining != 0:
  179.                     log.error('Block size error.')
  180.                     state = STATE_END
  181.                     continue
  182.                 
  183.                 if single_read:
  184.                     state = STATE_END
  185.                     continue
  186.                 state = STATE_FIXED_HEADER
  187.                 log.debug('Data: data=%d,block=%d,header=%d' % (data_remaining, block_remaining, header_remaining))
  188.                 continue
  189.             elif record_type == RT_RASTER:
  190.                 (unused, data_size) = record
  191.                 log.debug('Raster record: (data size=%d(0x%x))' % (data_size, data_size))
  192.                 data = data[RASTER_RECORD_SIZE:]
  193.                 block_remaining -= RASTER_RECORD_SIZE
  194.                 data_remaining -= RASTER_RECORD_SIZE
  195.                 log.debug('Data: data=%d,block=%d,header=%d' % (data_remaining, block_remaining, header_remaining))
  196.                 if block_remaining > 0 and data_remaining > 0:
  197.                     log.debug('Writing remainder of data...')
  198.                     data_len = len(data)
  199.                     log.debug('Data len=%d(0x%x)' % (data_len, data_len))
  200.                     stream.write(data[:block_remaining])
  201.                     block_remaining -= data_len
  202.                     data_remaining -= data_len
  203.                     if data_remaining != 0:
  204.                         log.error('Data size error')
  205.                         state = STATE_END
  206.                         continue
  207.                     
  208.                 
  209.                 while block_remaining > 0:
  210.                     if endScan:
  211.                         break
  212.                     
  213.                     log.debug('Reading more data from device...')
  214.                     (fields, data) = device.readChannel(channel_id)
  215.                     if callback is not None:
  216.                         endScan = callback()
  217.                     
  218.                     data_len = len(data)
  219.                     log.debug('Data len=%d(0x%x)' % (data_len, data_len))
  220.                     stream.write(data[:block_remaining])
  221.                     total_bytes += data_len
  222.                     block_remaining -= data_len
  223.                 if block_remaining != 0:
  224.                     log.error('Block size error.')
  225.                     state = STATE_END
  226.                     continue
  227.                 
  228.                 state = STATE_FIXED_HEADER
  229.                 continue
  230.             elif record_type == RT_END_PAGE:
  231.                 (unused1, unused2, unused3, black_rows, cmy_rows) = record
  232.                 log.debug('End page record: (black_rows=%d,cmy_rows=%d)' % (black_rows, cmy_rows))
  233.                 data = data[EOP_RECORD_SIZE:]
  234.                 block_remaining -= EOP_RECORD_SIZE
  235.                 data_remaining -= EOP_RECORD_SIZE
  236.                 if block_remaining != 0:
  237.                     log.error('Block size error.')
  238.                 
  239.                 log.debug('Data: data=%d,block=%d,header=%d' % (data_remaining, block_remaining, header_remaining))
  240.                 if page_flags & PAGE_FLAG_END_DOC or page_flags & PAGE_FLAG_END_STREAM:
  241.                     state = STATE_END
  242.                     continue
  243.                 state = STATE_FIXED_HEADER
  244.                 continue
  245.             
  246.         record_type == RT_START_PAGE
  247.     log.debug('Read %d bytes' % total_bytes)
  248.     return endScan
  249.  
  250.  
  251. def buildMFPDTFBlock(data_type, page_flags = 0, send_variant = False, data = None):
  252.     block = cStringIO.StringIO()
  253.     block.write(struct.pack('<I', 0))
  254.     header_len = FIXED_HEADER_SIZE
  255.     if send_variant:
  256.         if data_type == DT_DIAL_STRINGS:
  257.             header_len += DIAL_STRINGS_VARIANT_HEADER_SIZE
  258.         elif data_type == DT_FAX_IMAGES:
  259.             header_len += FAX_IMAGE_VARIANT_HEADER_SIZE
  260.         
  261.     
  262.     block.write(struct.pack('<H', header_len))
  263.     block.write(struct.pack('<B', data_type))
  264.     block.write(struct.pack('<B', page_flags))
  265.     if send_variant:
  266.         if data_type == DT_DIAL_STRINGS:
  267.             block.write(struct.pack('<BB', MAJOR_VER, MINOR_VER))
  268.             block.write(struct.pack('<H', 1))
  269.             block.write(struct.pack('<H', 51))
  270.         elif data_type == DT_FAX_IMAGES:
  271.             block.write(struct.pack('<BB', MAJOR_VER, MINOR_VER))
  272.             block.write(struct.pack('<B', SRC_HOST))
  273.             block.write(struct.pack('<H', 1))
  274.             block.write(struct.pack('<B', TTI_NONE))
  275.             block.write(struct.pack('<I', 0))
  276.             block.write('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
  277.             block.write('                    ')
  278.             block.write('                    ')
  279.             block.write('<I', 0)
  280.         
  281.     
  282.     if data_type == DT_DIAL_STRINGS:
  283.         if data is not None:
  284.             dial_string = data['dial-string']
  285.             block.write(dial_string)
  286.             block.write('\x00' * (51 - len(dial_string)))
  287.         
  288.     elif data_type == DT_FAX_IMAGES:
  289.         pass
  290.     
  291.  
  292.