verify.c
上传用户:hkgotone
上传日期:2013-02-17
资源大小:293k
文件大小:8k
源码类别:

Windows Mobile

开发平台:

C/C++

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