www.pudn.com > MPEG2systemsrc.rar > SectionConsumers.H

/* Copyright (C) 1995, Tektronix Inc. All Rights Reserved.
 *
 *   Usage Restrictions
 *
 * License is granted to copy, to use, and to make and to use derivative
 * works for research and evaluation purposes only.
 *
 *   Disclaimer of Warranty
 *
 * These software programs are available to the user without any license
 * fee or royalty on an "as is" basis.  Tektronix Inc. disclaims any and
 * all warranties, whether express, implied, or statuary, including any
 * implied warranties or merchantability or of fitness for a particular
 * purpose.  In no event shall the copyright-holder be liable for any 
 * incidental, punitive, or consequential damages of any kind whatsoever
 * arising from the use of these programs.
 *
 * This disclaimer of warranty extends to the user of these programs and
 * user's customers, employees, agents, transferees, successors, and
 * assigns.
 *
 * The Tektronix Inc. does not represent or warrant that the programs
 * furnished hereunder are free of infringement of any third-party
 * patents.
*/

/* SectionConsumer classes */
#ifndef sectionconsumer_h
#define sectionconsumer_h

#include "Consumer.H"
#include "Section.H"
#include "Decoder.H"

// SectionConsumer State
#define SCHEAD1 1
#define SCHEAD2 2
#define SCFLUSH 3

class SectionConsumer : public Consumer
{
public:
  SectionConsumer (Decoder*, Section*);
  virtual int read_partial (int);
  virtual void read_section () = 0;
protected:
  Section* sec;
  void read_header_a ();           // table_id .. section_length
  void read_header_b ();           // reserved .. last_section_number
  void read_CRC ();
  char* buf;
  int buf_index;
  int length_expected;
};

class PATConsumer : public SectionConsumer
{
public:
  PATConsumer (Decoder*, PATSection*);
  virtual void read_section ();
private:
  PATSection* patsec;
};

class MapConsumer : public SectionConsumer
{
public:
  MapConsumer (Decoder*, MapSection*);
  virtual void read_section ();
private:
  MapSection* mapsec;
};

class CAConsumer : public SectionConsumer
{
public:
  CAConsumer (Decoder*, CASection*);
  virtual void read_section ();
private:
  CASection* casec;
};

class PriConsumer : public SectionConsumer
{
public:
  PriConsumer (Decoder*, PriSection*);
  virtual void read_section ();
private:
  PriSection* prisec;
};

/*
 DOCUMENTATION

 SectionConsumer is a base class from which the PSI-related Consumers
 PATConsumer, MapConsumer, and CAConsumer are derived.

 Since the syntax for these sections is similar reproduction of code
 is avoided by defining read_partial in the base class SectionProducer
 and calling the virtual function read_section.  read_section is
 defined in each of the derived classes.  The definitions of
 read_section, then, use as utilities the functions read_header_a and
 read_header_b, which are defined back in the base class. 

 Note that the syntax objects: casec, mapsec and patsec are stored
 twice in each structure.  Once under the generic name "sec" and once
 under the more specific name.  This is a hack to work around a
 well-known and annoying C++ strong-typing problem; if you don't mind
 the extra pointer and they are "write-once", then it's a pretty
 effective solution.

*/
 
#endif