Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
1085 | pj | 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 |