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@linuxtv.org>
  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)
