Thanks go to the following people for patches and contributions:

Michael Hunold <m.hunold@gmx.de>
  for the initial saa7146 driver and its recent overhaul

Christian Theiss
  for his work on the initial Linux DVB driver

Marcus Metzler <mocm@metzlerbros.de>
Ralph Metzler <rjkm@metzlerbros.de>
  for their continuing work on the DVB driver

Michael Holzt <kju@debian.org>
  for his contributions to the dvb-net driver

Diego Picciani <d.picciani@novacomp.it>
  for CyberLogin for Linux which allows logging onto EON
  (in case you are wondering where CyberLogin is, EON changed its login
  procedure and CyberLogin is no longer used.)

Martin Schaller <martin@smurf.franken.de>
  for patching the cable card decoder driver

Klaus Schmidinger <Klaus.Schmidinger@cadsoft.de>
  for various fixes regarding tuning, OSD and CI stuff and his work on VDR

Steve Brown <sbrown@cortland.com>
  for his AFC kernel thread

Christoph Martin <martin@uni-mainz.de>
  for his LIRC infrared handler

Andreas Oberritter <obi@linuxtv.org>
Dennis Noermann <dennis.noermann@noernet.de>
Felix Domke <tmbinc@elitedvb.net>
Florian Schirmer <jolt@tuxbox.org>
Ronny Strutz <3des@elitedvb.de>
Wolfram Joost <dbox2@frokaschwei.de>
...and all the other dbox2 people
  for many bugfixes in the generic DVB Core, frontend drivers and
  their work on the dbox2 port of the DVB driver

Oliver Endriss <o.endriss@gmx.de>
  for many bugfixes

Andrew de Quincey <adq_dvb@lidskialf.net>
  for the tda1004x frontend driver, and various bugfixes

Peter Schildmann <peter.schildmann@web.de>
  for the driver for the Technisat SkyStar2 PCI DVB card

Vadim Catana <skystar@moldova.cc>
Roberto Ragusa <r.ragusa@libero.it>
Augusto Cardoso <augusto@carhil.net>
  for all the work for the FlexCopII chipset by B2C2,Inc.

Davor Emard <emard@softhome.net>
  for his work on the budget drivers, the demux code,
  the module unloading problems, ...

Hans-Frieder Vogt <hfvogt@arcor.de>
  for his work on calculating and checking the crc's for the
  TechnoTrend/Hauppauge DEC driver firmware

Michael Dreher <michael@5dot1.de>
Andreas 'randy' Weinberger
  for the support of the Fujitsu-Siemens Activy budget DVB-S

Kenneth Aafløy <ke-aa@frisurf.no>
  for adding support for Typhoon DVB-S budget card

Ernst Peinlich <e.peinlich@inode.at>
  for tuning/DiSEqC support for the DEC 3000-s

Peter Beutner <p.beutner@gmx.net>
  for the IR code for the ttusb-dec driver

Wilson Michaels <wilsonmichaels@earthlink.net>
  for the lgdt330x frontend driver, and various bugfixes

Michael Krufky <mkrufky@m1k.net>
  for maintaining v4l/dvb inter-tree dependencies

Taylor Jacob <rtjacob@earthlink.net>
  for the nxt2002 frontend driver

Jean-Francois Thibert <jeanfrancois@sagetv.com>
  for the nxt2004 frontend driver

Kirk Lapray <kirk.lapray@gmail.com>
  for the or51211 and or51132 frontend drivers, and
  for merging the nxt2002 and nxt2004 modules into a
  single nxt200x frontend driver.

(If you think you should be in this list, but you are not, drop a
 line to the DVB mailing list)
