GETHDR.C

/************************************************************************
 *
 *  gethdr.c, header decoding for tmndecode (H.263 decoder)
 *  Copyright (C) 1995, 1996  Telenor R&D, Norway
 *
 *  Contacts:
 *  Robert Danielsen                  <Robert.Danielsen@nta.no>
 *
 *  Telenor Research and Development  http://www.nta.no/brukere/DVC/
 *  P.O.Box 83                        tel.:   +47 63 84 84 00
 *  N-2007 Kjeller, Norway            fax.:   +47 63 81 00 76
 *
 *  Copyright (C) 1997  University of BC, Canada
 *  Modified by: Michael Gallant <mikeg@ee.ubc.ca>
 *               Guy Cote <guyc@ee.ubc.ca>
 *               Berna Erol <bernae@ee.ubc.ca>
 *
 *  Contacts:
 *  Michael Gallant                   <mikeg@ee.ubc.ca>
 *
 *  UBC Image Processing Laboratory   http://www.ee.ubc.ca/image
 *  2356 Main Mall                    tel.: +1 604 822 4051
 *  Vancouver BC Canada V6T1Z4        fax.: +1 604 822 5949
 *
 ************************************************************************/

/* Disclaimer of Warranty
 * 
 * These software programs are available to the user without any license fee
 * or royalty on an "as is" basis. The University of British Columbia
 * 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 University of British Columbia does not represent or warrant that the
 * programs furnished hereunder are free of infringement of any
 * third-party patents.
 * 
 * Commercial implementations of H.263, including shareware, are subject to
 * royalty fees to patent holders.  Many of these patents are general
 * enough such that they are unavoidable regardless of implementation
 * design.
 * 
 */


/* modified to support annex O true B frames, mikeg@ee.ubc.ca
 * 
 * modified to support general H.263+ syntax, bernae@ee.ubc.ca
 * 
 * based on mpeg2decode, (C) 1994, MPEG Software Simulation Group and
 * mpeg2play, (C) 1994 Stefan Eckart <stefan@lis.e-technik.tu-muenchen.de> */


#include <stdio.h>
#include <stdlib.h>

#include "config.h"
#include "tmndec.h"
#include "global.h"

/* private prototypes */
static void getpicturehdr _ANSI_ARGS_ ((void));

/* decode headers from one input stream until an End of Sequence or
 * picture start code is found */

int getheader ()
{
  unsigned int code, gob;

  /* look for startcode */
  startcode ();
  code = getbits (PSC_LENGTH);
  gob = getbits (5);
  if (gob == SE_CODE)
    return 0;
  if (gob == 0)
  {
    getpicturehdr ();
    if (syntax_arith_coding)    /* reset decoder after receiving */
      decoder_reset ();         /* fixed length PSC string */
  } 
  return gob + 1;
}


/* align to start of next startcode */

void startcode ()
{
  /* search for new picture start code */
  while (showbits (PSC_LENGTH) != 1l)
    flushbits (1);
}

/* decode picture header */

static void getpicturehdr ()
{
  int pos, pei, tmp;
  int TRPI = 0;
  int BCI = 0;
  int clock_conversion_code = 0;
  int clock_divisor = 0;
  int extended_temporal_reference = 0;

  UFEP = 0;

  pos = ld->bitcnt;

  temp_ref = getbits (8);

  if (trd < 0)
    trd += 256;

  tmp = getbits (1);            /* always "1" */
  
  tmp = getbits (1);            /* always "0" */
  
  tmp = getbits (1);            /* split_screen_indicator */
  
  if (tmp)
  {
     exit (-1);
  }
  
  tmp = getbits (1);            /* document_camera_indicator */
  
  tmp = getbits (1);            /* freeze_picture_release */
  
  tmp = getbits (3);
  
  if (tmp == 0)
  {
     exit (-1);
  }
  
  if (tmp == EXTENDED_PTYPE)
  {
    plus_type = 1;
    UFEP = getbits (3);
  
        if (UFEP == 1)
    {                           /* OPPTYPE */
      source_format = getbits (3);
    
      /* optional custom picture clock frequency */
      optional_custom_PCF = getbits (1);
    
          if (optional_custom_PCF)
      {
        exit (-1);
      }
      mv_outside_frame = getbits (1);
      
      long_vectors = (mv_outside_frame ? 1 : 0);
      syntax_arith_coding = getbits (1);
      
          adv_pred_mode = getbits (1);
      
      mv_outside_frame = (adv_pred_mode ? 1 : mv_outside_frame);
      overlapping_MC = (adv_pred_mode ? 1 : 0);
      use_4mv = (adv_pred_mode ? 1 : 0);
      pb_frame = 0;
      advanced_intra_coding = getbits (1);
      
      deblocking_filter_mode = getbits (1);
      
      mv_outside_frame = (deblocking_filter_mode ? 1 : mv_outside_frame);
      use_4mv = (deblocking_filter_mode ? 1 : use_4mv);

      slice_structured_mode = getbits (1);
      
      if (slice_structured_mode)
      {
         exit (-1);
      }
      reference_picture_selection_mode = getbits (1);
      
      independently_segmented_decoding_mode = getbits (1);
      
      if (independently_segmented_decoding_mode)
      {
        exit (-1);
      }
      alternative_inter_VLC_mode = getbits (1);
      
      modified_quantization_mode = getbits (1);
      
          tmp = getbits (4);
      
      if (tmp != 8)
      {                         /* OPPTYPE : bit15=1, bit16,bit17,bit18=0 */
          exit (-1);
      }
    }
    if ((UFEP == 1) || (UFEP == 0))
    {
      if (UFEP == 0)
      {
        if (scalability_mode >= 3)
        {
          horizontal_size = lines[base_source_format];
          vertical_size = pels[base_source_format];

          mb_width = horizontal_size / 16;
          mb_height = vertical_size / 16;

          /* Need to store previous (reference layer) values 
           * for interpolation purposes, as the new values, 
           * i.e. of the spatially scaled layer, depend on 
           * the type of spatial scalability in use. */
          ref_coded_picture_width = coded_picture_width = horizontal_size;
          ref_coded_picture_height = coded_picture_height = vertical_size;
          ref_chrom_width = chrom_width = coded_picture_width >> 1;
          ref_chrom_height = chrom_height = coded_picture_height >> 1;

          source_format = base_source_format;
        }
      }

      /* MMPTYPE */
      
      pict_type = getbits (3);
      
      if (pict_type == PCT_IPB)
        pb_frame = IM_PB_FRAMES;
      else
        pb_frame = 0;

      if (PCT_B == pict_type)
      {
        true_B_frame = ON;
        /* Allow motion over picture boundaries, regardless of whether or
         * not UMV is turned on. */
        mv_outside_frame = 1;
        true_b_trb = temp_ref - prev_non_disposable_temp_ref;
        if (true_b_trb < 0)
          true_b_trb += 256;
      } else
      {
        true_B_frame = OFF;
        prev_non_disposable_temp_ref = next_non_disposable_temp_ref;
        next_non_disposable_temp_ref = temp_ref;
        trd = temp_ref - prev_non_disposable_temp_ref;
        if (trd < 0)
          trd += 256;
      }

      reference_picture_resampling_mode = getbits (1);
      
      if (reference_picture_resampling_mode)
      {
         exit (-1);
      }
      reduced_resolution_update_mode = getbits (1);
      
      if (reduced_resolution_update_mode)
      {
          exit (-1);
      }
      rtype = getbits (1);      /* rounding type */
      
      
      tmp = getbits (3);
      
      if (tmp != 1)
      {                         /* MPPTYPE : bit7,bit8=0  bit9=1 */
        if (!quiet)
          exit (-1);
      }
    } else
    {
      /* UFEP is neither 001 nor 000 */
      exit (-1);
    }

    tmp = getbits (1);
    
    if (tmp)
    {
      exit (-1);
    }
  
    if (UFEP && (source_format == SF_CUSTOM))
    {
      /* Read custom picture format */
      CP_PAR_code = getbits (4);
      if (CP_PAR_code != PAR_CIF)
      {
        exit(-1);
      }
      tmp=getbits (9);
      horizontal_size = (tmp + 1 ) * 4;
      tmp = getbits (1);
      if (!tmp)
      {
         exit (-1);
      }
      tmp = getbits (9);
      vertical_size = tmp * 4;
      if ((horizontal_size%16) || (vertical_size%16))
      {
        exit (-1);
      }

      if (CP_PAR_code == EXTENDED_PAR)
      {
        PAR_width = getbits (8);
        PAR_height = getbits (8);
      }
    }

    if (source_format != SF_CUSTOM)
    {
        horizontal_size = lines[source_format];
        vertical_size = pels[source_format];

    }
    mb_width = horizontal_size / 16;
    mb_height = vertical_size / 16;

   /* Need to store previous (reference layer) values 
    * for interpolation purposes, as the new values, 
    * i.e. of the spatially scaled layer, depend on 
    * the type of spatial scalability in use. */
    ref_coded_picture_width = coded_picture_width;
    coded_picture_width = horizontal_size;

    ref_coded_picture_height = coded_picture_height;
    coded_picture_height = vertical_size;

    ref_chrom_width = chrom_width; 
    chrom_width = coded_picture_width >> 1;

    ref_chrom_height = chrom_height;
    chrom_height = coded_picture_height >> 1;
    
    if (optional_custom_PCF)
    {
      if (UFEP)
      {
        clock_conversion_code = getbits (1);
        clock_divisor = getbits (7);
        CP_clock_frequency = (int) (1800 / ((float) clock_divisor * (8 + clock_conversion_code)) * 1000);
      }
      /* regardless of the value of UFEP */
      extended_temporal_reference = getbits (2);
      temp_ref = extended_temporal_reference << 8 + temp_ref;

      if (PCT_B == pict_type)
      {
        true_b_trb = temp_ref - prev_non_disposable_temp_ref;
      } else
      {
        trd = temp_ref - prev_non_disposable_temp_ref;
      }

      if (trd < 0)
        trd += 1024;
    }
    if (UFEP && long_vectors)
    {
      if (getbits(1)) 
      {
        unlimited_unrestricted_motion_vectors = 0;
      }
      else 
      {
        flushbits(1);
        unlimited_unrestricted_motion_vectors = 1;
      }
    }
    if (UFEP && slice_structured_mode)
    {
      SSS_rectangular_slices = getbits (1);
      SSS_arbitary_slice_ordering = getbits (1);
    
    }

    if ((pict_type == PCT_B) || (pict_type == PCT_EI) || (pict_type == PCT_EP))
    {
      /* optional temporal, SNR and spatial scalability mode in use */
      enhancement_layer_num = getbits (4);
      if (UFEP)
      {
        reference_layer_number = getbits (4);
      }
      if (1 != enhancement_layer_num)
      {
        if (source_format != base_source_format)
        {
          if (source_format != SF_CUSTOM)
          {
            scalability_mode = SPATIAL_SCALABILITY_HV;
          }
          else if (coded_picture_width != ref_coded_picture_width)
          {
            scalability_mode = SPATIAL_SCALABILITY_H;
          }
          else 
          {
            scalability_mode = SPATIAL_SCALABILITY_V;
          }
        }
        else
        {
          scalability_mode = SNR_SCALABILITY;
        }
      }   
    }
    else
    {
      enhancement_layer_num = reference_layer_number = 1;
    }

    if (reference_picture_selection_mode)
    {
      if (UFEP)
      {
        MF_of_reference_picture_selection = getbits (3);
      }
      TRPI = getbits (1);
      if (TRPI)
      {
        /* temporal reference for prediction exists */
        
        temporal_reference_for_prediction = getbits (10);
      }
      if (showbits (1))
      {
        /* backward channel message exists */
        /* BCM(backward channel message) is not implemented */
        flushbits (1);
        exit (-1);
      }
      else
      {
        /* BCM is not present */
        BCI = getbits (2);
      }  
    }
    if (reference_picture_resampling_mode)
    {
        /* reading RPRP info is not implemented */
      exit (-1);
    }
    pic_quant = getbits (5);
    quant = pic_quant;

  } 
  else
  {
    plus_type = 0;
    rtype = 0;
    source_format = tmp;
    enhancement_layer_num = reference_layer_number = 1;

    horizontal_size = lines[source_format];
    vertical_size = pels[source_format];

    mb_width = horizontal_size / 16;
    mb_height = vertical_size / 16;

    /* Need to store previous (reference layer) values 
     * for interpolation purposes, as the new values, 
     * i.e. of the spatially scaled layer, depend on 
     * the type of spatial scalability in use. */
    ref_coded_picture_width = coded_picture_width = horizontal_size;
    ref_coded_picture_height = coded_picture_height = vertical_size;
    ref_chrom_width = chrom_width = coded_picture_width >> 1;
    ref_chrom_height = chrom_height = coded_picture_height >> 1;

    true_B_frame = OFF;
    prev_non_disposable_temp_ref = next_non_disposable_temp_ref;
    next_non_disposable_temp_ref = temp_ref;
    trd = temp_ref - prev_non_disposable_temp_ref;
    if (trd < 0)
      trd += 256;

    pict_type = getbits (1);
    mv_outside_frame = getbits (1);
    long_vectors = (mv_outside_frame ? 1 : 0);
    syntax_arith_coding = getbits (1);
    adv_pred_mode = getbits (1);
    mv_outside_frame = (adv_pred_mode ? 1 : mv_outside_frame);
    overlapping_MC = (adv_pred_mode ? 1 : 0);
    use_4mv = (adv_pred_mode ? 1 : 0);
    pb_frame = getbits (1);
   
    pic_quant = getbits (5);
    quant = pic_quant;


    tmp = getbits (1);
    if (tmp)
    {
      exit (-1);
    }
  }

  if (pb_frame)
  {
    if (optional_custom_PCF)
    {
      trb = getbits (5);
    } else
    {
      trb = getbits (3);
    }

    bquant = getbits (2);
  } else
  {
    trb = 0;
  }

#ifdef USE_TIME
  if (framerate > 0 && trd > 0)
    doframerate (0);
#endif

  pei = getbits (1);

pspare:
  if (pei)
  {
    /* extra info for possible future backward compatible additions */
    getbits (8);                /* not used */
    pei = getbits (1);
    if (pei)
      goto pspare;              /* keep on reading pspare until pei=0 */
  }
}

/* get the GOB header */
/* author: <guyc@ece.ubc.ca */
void getgobheader()
{
  int BCI = 0;  
  /* GFID is not allowed to change unless PTYPE in picture header
   * changes */
  gfid = getbits (2);
  /* NB: in error-prone environments the decoder can use this
  * value to determine whether a picture header where the PTYPE
  * has changed, has been lost */
  /* we now use it and assume that a picture change is *
   * from INTRA to INTER or INTER to INTRA only */
  if (gfid != pgfid && newgob)
  {
    if (pict_type == PCT_INTRA)
      pict_type = PCT_INTER;
    else if (pict_type == PCT_INTER)
      pict_type = PCT_INTRA;
  }
  
  quant = getbits (5);
  /* Support for Annex N at the GOB level */
  if (reference_picture_selection_mode)
  {
    TRI = getbits (1);
    if (TRI)
    {
      /* Temporal reference of GOB */
      temp_ref = optional_custom_PCF?getbits (10):getbits(8);
    }
    /* Temporal Reference for Prediction indication bit */
    TRPI = getbits (1);
    if (TRPI)
    {
      /* temporal reference for prediction exists */
      temporal_reference_for_prediction = getbits (10);
    }
    if (showbits (1))
    {
      /* backward channel message exists */
      /* BCM(backward channel message) is not implemented */
      flushbits (1);
      exit (-1);
    }
    else
    {
      /* BCM is not present */
      BCI = getbits (2);
    }  
  }
  pgfid = gfid;
}
void initoptions ()
{
  mv_outside_frame = 0;
  syntax_arith_coding = 0;
  adv_pred_mode = 0;
  pb_frame = 0;
  long_vectors = 0;

  plus_type = 0;
  optional_custom_PCF = 0;
  advanced_intra_coding = 0;
  deblocking_filter_mode = 0;
  slice_structured_mode = 0;
  reference_picture_selection_mode = 0;
  independently_segmented_decoding_mode = 0;
  alternative_inter_VLC_mode = 0;
  modified_quantization_mode = 0;
  reduced_resolution_update_mode = 0;
  reference_picture_resampling_mode = 0;
  rtype = 0;
}

---