src/gdcmmpeg2/src/mpeg2dec/verify.c

   1 /* verify.c
   2  *
   3  * Bitstream verification routines
   4  *
   5  *
   6  */
   7 #ifdef VERIFY
   8
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <ctype.h>
  12 #include <fcntl.h>
  13 #include <math.h>     /* needed for ceil() */
  14
  15 #include "config.h"
  16 #include "global.h"
  17
  18 /* #define DEBUG  */
  19 #ifdef DEBUG
  20 #define PC
  21 #endif
  22
  23 #ifdef PC
  24 #include <conio.h>    /* needed for getch() */
  25 #endif /* PC */
  26
  27 /*
  28    Check picture headers:  due to the VBV definition of picture data,
  29    this routine must be called immediately before any picture data
  30    is parsed. (before the first slice start code, including any slice
  31    start code stuffing).
  32 */
  33
  34
  35 static void Check_VBV_Delay _ANSI_ARGS_((int Bitstream_Framenum, int Sequence_Framenum));
  36
  37
  38 void Check_Headers(Bitstream_Framenum, Sequence_Framenum)
  39 int Bitstream_Framenum;
  40 int Sequence_Framenum;
  41 {
  42
  43
  44   if((!low_delay)&&(vbv_delay!=0)&&(vbv_delay!=0xFFFF))
  45     Check_VBV_Delay(Bitstream_Framenum, Sequence_Framenum);
  46
  47   /* clear out the header tracking variables so we have an accurate
  48      count next time */
  49   Clear_Verify_Headers();
  50 }
  51
  52
  53
  54 /*
  55  * Verify vbv_delay value in picture header
  56  * (low_delay==1 checks not implemented. this does not exhaustively test all
  57  *  possibilities suggested in ISO/IEC 13818-2 Annex C.  It only checks
  58  *  for constant rate streams)
  59  *
  60  * Q:how do we tell a variable rate stream from a constant rate stream anyway?
  61  *   it's not as simple as vbv_delay==0xFFFF, since we need meaningful
  62  *   vbv_delay values to calculate the piecewise rate in the first place!
  63  *
  64  * Also: no special provisions at the beginning or end of a sequence
  65  */
  66
  67 static void Check_VBV_Delay(Bitstream_Framenum, Sequence_Framenum)
  68 int Bitstream_Framenum;
  69 int Sequence_Framenum;
  70 {
  71   double B;   /* buffer size                   */
  72   double Bn;  /* buffer fullness for picture n */
  73   double R;   /* bitrate                       */
  74   double I;   /* time interval (t[n+1] - t[n]) */
  75   double T;   /* inverse of the frame rate (frame period) */
  76
  77   int d;
  78   int internal_vbv_delay;
  79
  80   static int previous_IorP_picture_structure;
  81   static int previous_IorP_repeat_first_field;
  82   static int previous_IorP_top_field_first;
  83   static int previous_vbv_delay;
  84   static int previous_bitstream_position;
  85
  86   static double previous_Bn;
  87   static double E;      /* maximum quantization error or mismatch */
  88
  89
  90
  91   if((Sequence_Framenum==0)&&(!Second_Field))
  92   {  /* first coded picture of sequence */
  93
  94     R = bit_rate;
  95
  96     /* the initial buffer occupancy is taken on faith
  97        that is, we believe what is transmitted in the first coded picture header
  98        to be the true/actual buffer occupancy */
  99
 100     Bn = (R * (double) vbv_delay) / 90000.0;
 101     B = 16 * 1024 * vbv_buffer_size;
 102
 103
 104     /* maximum quantization error in bitrate (bit_rate_value is quantized/
 105        rounded-up to units of 400 bits/sec as per ISO/IEC 13818-2
 106        section 6.3.3 */
 107
 108     E = (400.0/frame_rate) + 400;
 109
 110 #ifdef DEBUG
 111     printf("vbv_buffer_size (B) = %.0f, Bn=%f, E=%f, \nbitrate=%f, vbv_delay=%d frame_rate=%f\n",
 112       B, Bn, E, bit_rate, vbv_delay, frame_rate);
 113 #endif
 114
 115   }
 116   else /* not the first coded picture of sequence */
 117   {
 118
 119     /* derive the interval (I).  The interval tells us how many constant rate bits
 120      * will have been downloaded to the buffer during the current picture period
 121      *
 122      * interval assumes that:
 123      *  1. whilst we are decoding the current I or P picture, we are displaying
 124      *     the previous I or P picture which was stored in the reorder
 125      *     buffer (pointed to by forward_reference_frame in this implementation)
 126      *
 127      *  2. B pictures are output ("displayed") at the time when they are decoded
 128      *
 129      */
 130
 131     if(progressive_sequence) /* Annex C.9 (progressive_sequence==1, low_delay==0) */
 132     {
 133
 134       T = 1/frame_rate; /* inverse of the frame rate (frame period) */
 135
 136       if(picture_coding_type==B_TYPE)
 137       {
 138         if(repeat_first_field==1)
 139         {
 140           if(top_field_first==1)
 141             I = T*3;  /* three frame periods */
 142           else
 143             I = T*2;  /* two frame periods */
 144         }
 145         else
 146           I = T;      /* one frame period */
 147       }
 148       else /* P or I frame */
 149       {
 150         if(previous_IorP_repeat_first_field==1)
 151         {
 152           if(previous_IorP_top_field_first==1)
 153             I = 3*T;
 154           else
 155             I = 2*T;
 156         }
 157         else
 158           I = T;
 159       }
 160     }
 161     else /* Annex C.11 (progressive_sequence==0, low_delay==0) */
 162     {
 163
 164       T = 1/(2*frame_rate); /* inverse of two times the frame rate (field period) */
 165
 166       if(picture_coding_type==B_TYPE)
 167       {
 168         if(picture_structure==FRAME_PICTURE)
 169         {
 170           if(repeat_first_field==0)
 171             I = 2*T;  /* two field periods */
 172           else
 173             I = 3*T;  /* three field periods */
 174         }
 175         else /* B field */
 176         {
 177           I = T;      /* one field period */
 178         }
 179       }
 180       else /* I or P picture */
 181       {
 182         if(picture_structure==FRAME_PICTURE)
 183         {
 184           if(previous_IorP_repeat_first_field==0)
 185             I = 2*T;
 186           else
 187             I = 3*T;
 188         }
 189         else
 190         {
 191           if(Second_Field==0)  /* first field of current frame */
 192             I = T;
 193           else /* second field of current frame */
 194           {
 195             /* formula: previous I or P display period (2*T or 3*T) minus the
 196                very recent decode period (T) of the first field of the current
 197                frame */
 198
 199             if(previous_IorP_picture_structure!=FRAME_PICTURE
 200               || previous_IorP_repeat_first_field==0)
 201               I = 2*T - T;  /* a net of one field period */
 202             else if(previous_IorP_picture_structure==FRAME_PICTURE
 203               && previous_IorP_repeat_first_field==1)
 204               I = 3*T - T;  /* a net of two field periods */
 205           }
 206         }
 207       }
 208     }
 209
 210     /* derive coded size of previous picture */
 211     d  = ld->Bitcnt - previous_bitstream_position;
 212
 213     /* Rate = Distance/Time */
 214
 215     /* piecewise constant rate (variable rate stream) calculation
 216      * R =  ((double) d /((previous_vbv_delay - vbv_delay)/90000 + I));
 217      */
 218
 219     R = bit_rate;
 220
 221     /* compute buffer fullness just before removing picture n
 222      *
 223      * Bn = previous_Bn + (I*R) - d;     (recursive formula)
 224      *
 225      *   where:
 226      *
 227      *    n           is the current picture
 228      *
 229      *    Bn          is the buffer fullness for the current picture
 230      *
 231      *    previous_Bn is the buffer fullness of the previous picture
 232      *
 233      *    (I*R )      is the bits accumulated during the current picture
 234      *                period
 235      *
 236      *    d           is the number of bits removed during the decoding of the
 237      *                previous picture
 238      */
 239
 240     Bn = previous_Bn + (I*R) - d;
 241
 242     /* compute internally derived vbv_delay (rouding up with ceil()) */
 243     internal_vbv_delay = (int) ceil((90000 * Bn / bit_rate));
 244
 245 #ifdef DEBUG
 246     printf("\nvbv_delay: internal=%d, bitstream=%d\n", internal_vbv_delay, vbv_delay);
 247
 248     printf("Bn=%f, prevBn=%f, I=%f, R=%f, d=%d\n", Bn, previous_Bn, I, R, d);
 249     printf("frame(%d), pictstruct(%d), picttype(%d)\n", Sequence_Framenum,
 250       picture_structure, picture_coding_type);
 251
 252     /* report error */
 253     if(internal_vbv_delay != vbv_delay)
 254     {
 255       printf("WARNING: internal_vbv_delay(%d) != vbv_delay(%d)\n",
 256         internal_vbv_delay, vbv_delay);
 257     }
 258 #endif
 259
 260   } /* not the first coded picture of sequence */
 261
 262
 263 #ifdef PC
 264   getch();
 265 #endif /* PC */
 266
 267   /* update generic tracking variables */
 268   previous_bitstream_position = ld->Bitcnt ;
 269   previous_vbv_delay          = vbv_delay;
 270   previous_Bn                 = Bn;
 271
 272   /* reference picture: reordered/delayed output picture */
 273   if(picture_coding_type!=B_TYPE)
 274   {
 275     previous_IorP_repeat_first_field = repeat_first_field;
 276     previous_IorP_top_field_first    = top_field_first;
 277     previous_IorP_picture_structure  = picture_structure;
 278   }
 279
 280 }
 281
 282
 283
 284 /* variables to keep track of the occurance of redundant headers between pictures */
 285 void Clear_Verify_Headers()
 286 {
 287   verify_sequence_header = 0;
 288   verify_group_of_pictures_header = 0;
 289   verify_picture_header = 0;
 290   verify_slice_header = 0;
 291   verify_sequence_extension = 0;
 292   verify_sequence_display_extension = 0;
 293   verify_quant_matrix_extension = 0;
 294   verify_sequence_scalable_extension = 0;
 295   verify_picture_display_extension = 0;
 296   verify_picture_coding_extension = 0;
 297   verify_picture_spatial_scalable_extension = 0;
 298   verify_picture_temporal_scalable_extension = 0;
 299   verify_copyright_extension = 0;
 300 }
 301
 302 #endif /* VERIFY */
 303