delete old library versions
[goodguy/cinelerra.git] / cinelerra-5.1 / libzmpeg3 / video / headers.C
1 #include "../libzmpeg3.h"
2
3 int zvideo_t::
4 get_seq_hdr()
5 {
6   int i;
7   int load_intra_quantizer_matrix, load_non_intra_quantizer_matrix;
8
9 //zmsg("1\n");
10   horizontal_size = vstream->get_bits(12);
11   vertical_size = vstream->get_bits(12);
12   //int aspect_ratio =
13     vstream->get_bits(4);
14   framerate_code = vstream->get_bits(4);
15   bitrate = vstream->get_bits(18);
16   vstream->get_bit_noptr(); /* marker bit (=1) */
17   //int vbv_buffer_size =
18     vstream->get_bits(10);
19   //int constrained_parameters_flag =
20     vstream->get_bit_noptr();
21   frame_rate = frame_rate_table[framerate_code];
22
23   load_intra_quantizer_matrix = vstream->get_bit_noptr();
24   if( load_intra_quantizer_matrix ) {
25     for( i=0; i<64; ++i )
26       intra_quantizer_matrix[zigzag_scan_table[i]] = vstream->get_byte_noptr();
27   }
28   else {
29     for( i=0; i<64; ++i )
30       intra_quantizer_matrix[i] = default_intra_quantizer_matrix[i];
31   }
32
33   load_non_intra_quantizer_matrix = vstream->get_bit_noptr();
34   if( load_non_intra_quantizer_matrix ) {
35     for( i=0; i<64; ++i )
36       non_intra_quantizer_matrix[zigzag_scan_table[i]] = vstream->get_byte_noptr();
37   }
38   else {
39     for( i=0; i<64; ++i )
40       non_intra_quantizer_matrix[i] = 16;
41   }
42
43 /* copy luminance to chrominance matrices */
44   for( i=0; i<64; ++i ) {
45     chroma_intra_quantizer_matrix[i] = intra_quantizer_matrix[i];
46     chroma_non_intra_quantizer_matrix[i] = non_intra_quantizer_matrix[i];
47   }
48
49 //zmsg("100\n");
50   return 0;
51 }
52
53
54 /* decode sequence extension */
55
56 int zvideo_t::
57 sequence_extension()
58 {
59   mpeg2 = 1;
60   scalable_mode = slice_decoder_t::sc_NONE; /* unless overwritten by seq. scal. ext. */
61   //int prof_lev =
62     vstream->get_byte_noptr();
63   prog_seq = vstream->get_bit_noptr();
64   chroma_format = vstream->get_bits(2);
65   int horizontal_size_extension = vstream->get_bits(2);
66   int vertical_size_extension = vstream->get_bits(2);
67   //int bit_rate_extension =
68     vstream->get_bits(12);
69   vstream->get_bit_noptr();
70   //int vbv_buffer_size_extension =
71     vstream->get_byte_noptr();
72   //int low_delay =
73     vstream->get_bit_noptr();
74   //int frame_rate_extension_n =
75     vstream->get_bits(2);
76   //int frame_rate_extension_d =
77     vstream->get_bits(5);
78   horizontal_size = (horizontal_size_extension << 12) | (horizontal_size & 0x0fff);
79   vertical_size = (vertical_size_extension << 12) | (vertical_size & 0x0fff);
80   return 0;
81 }
82
83
84 /* decode sequence display extension */
85
86 int zvideo_t::
87 sequence_display_extension()
88 {
89   // int video_format =
90     vstream->get_bits(3);
91   int colour_description = vstream->get_bit_noptr();
92
93   if( colour_description ) {
94     //int colour_primaries =
95       vstream->get_byte_noptr();
96     //int transfer_characteristics =
97       vstream->get_byte_noptr();
98     matrix_coefficients = vstream->get_byte_noptr();
99   }
100
101   //int display_horizontal_size =
102     vstream->get_bits(14);
103   vstream->get_bit_noptr();
104   //int display_vertical_size =
105     vstream->get_bits(14);
106   return 0;
107 }
108
109
110 /* decode quant matrix entension */
111
112 int zvideo_t::
113 quant_matrix_extension()
114 {
115   int i;
116   int load_intra_quantiser_matrix, load_non_intra_quantiser_matrix;
117   int load_chroma_intra_quantiser_matrix;
118   int load_chroma_non_intra_quantiser_matrix;
119
120   load_intra_quantiser_matrix = vstream->get_bit_noptr();
121   if( load_intra_quantiser_matrix != 0 ) {
122     for( i=0; i<64; ++i ) {
123       chroma_intra_quantizer_matrix[zigzag_scan_table[i]]
124         = intra_quantizer_matrix[zigzag_scan_table[i]]
125         = vstream->get_byte_noptr();
126     }
127   }
128
129   load_non_intra_quantiser_matrix = vstream->get_bit_noptr();
130   if( load_non_intra_quantiser_matrix != 0 ) {
131     for( i=0; i<64; ++i ) {
132       chroma_non_intra_quantizer_matrix[zigzag_scan_table[i]]
133         = non_intra_quantizer_matrix[zigzag_scan_table[i]]
134         = vstream->get_byte_noptr();
135     }
136   }
137
138   load_chroma_intra_quantiser_matrix = vstream->get_bit_noptr();
139   if( load_chroma_intra_quantiser_matrix != 0 ) {
140     for( i=0; i<64; ++i )
141       chroma_intra_quantizer_matrix[zigzag_scan_table[i]] = vstream->get_byte_noptr();
142   }
143
144   load_chroma_non_intra_quantiser_matrix = vstream->get_bit_noptr();
145   if( load_chroma_non_intra_quantiser_matrix != 0 ) {
146     for( i=0; i<64; ++i )
147       chroma_non_intra_quantizer_matrix[zigzag_scan_table[i]] = vstream->get_byte_noptr();
148   }
149
150   return 0;
151 }
152
153
154 /* decode sequence scalable extension */
155
156 int zvideo_t::
157 sequence_scalable_extension()
158 {
159   scalable_mode = vstream->get_bits(2) + 1; /* add 1 to make sc_DP != sc_NONE */
160   //int layer_id =
161     vstream->get_bits(4);
162
163   if( scalable_mode == slice_decoder_t::sc_SPAT ) {
164     llw = vstream->get_bits(14); /* lower_layer_prediction_horizontal_size */
165     vstream->get_bit_noptr();
166     llh = vstream->get_bits(14); /* lower_layer_prediction_vertical_size */
167     hm = vstream->get_bits(5);
168     hn = vstream->get_bits(5);
169     vm = vstream->get_bits(5);
170     vn = vstream->get_bits(5);
171   }
172
173   if( scalable_mode == slice_decoder_t::sc_TEMP )
174     zerr("temporal scalability not implemented\n");
175   return 0;
176 }
177
178
179 /* decode picture display extension */
180
181 int zvideo_t::
182 picture_display_extension()
183 {
184 //  short frame_centre_horizontal_offset[3];
185 //  short frame_centre_vertical_offset[3];
186 /* per spec */
187   int n = prog_seq ? (!repeatfirst ? 1 : (!topfirst ? 2 : 3)) :
188      pict_struct != pics_FRAME_PICTURE ? 1 : (!repeatfirst ? 2 : 3) ;
189
190   for( int i=0; i<n; ++i ) {
191     //frame_centre_horizontal_offset[i] = (short)
192       vstream->get_bits(16);
193     vstream->get_bit_noptr();
194     //frame_centre_vertical_offset[i] = (short)
195       vstream->get_bits(16);
196     vstream->get_bit_noptr();
197   }
198   return 0;
199 }
200
201
202 /* decode picture coding extension */
203
204 int zvideo_t::
205 picture_coding_extension()
206 {
207   h_forw_r_size = vstream->get_bits(4) - 1;
208   v_forw_r_size = vstream->get_bits(4) - 1;
209   h_back_r_size = vstream->get_bits(4) - 1;
210   v_back_r_size = vstream->get_bits(4) - 1;
211   dc_prec = vstream->get_bits(2);
212   pict_struct = vstream->get_bits(2);
213   topfirst = vstream->get_bit_noptr();
214   frame_pred_dct = vstream->get_bit_noptr();
215   conceal_mv = vstream->get_bit_noptr();
216   qscale_type = vstream->get_bit_noptr();
217   intravlc = vstream->get_bit_noptr();
218   altscan = vstream->get_bit_noptr();
219   repeatfirst = vstream->get_bit_noptr();
220   //int chroma_420_type =
221     vstream->get_bit_noptr();
222   prog_frame = vstream->get_bit_noptr();
223   if( repeat_fields > 2 ) repeat_fields = 0;
224   repeat_fields += 2;
225   if( repeatfirst ) {
226     if( prog_seq ) repeat_fields += !topfirst ? 2 : 4;
227     else if( prog_frame ) ++repeat_fields;
228   }
229   current_field = 0;
230
231 //static const char *pstruct[] = { "nil", "top", "bot", "fld" };
232 //zmsgs("pstruct %s prog_seq%d prog_frame%d topfirst%d repeatfirst%d repeat_fields%d\n", 
233 //  pstruct[pict_struct], prog_seq , prog_frame, topfirst, repeatfirst, repeat_fields);
234
235   int composite_display_flag = vstream->get_bit_noptr();
236   if( composite_display_flag ) {
237     //int v_axis =
238       vstream->get_bit_noptr();
239     field_sequence = vstream->get_bits(3);
240     //int sub_carrier =
241       vstream->get_bit_noptr();
242     //int burst_amplitude =
243       vstream->get_bits(7);
244     //int sub_carrier_phase =
245       vstream->get_byte_noptr();
246   }
247   return 0;
248 }
249
250 /* decode picture spatial scalable extension */
251
252 int zvideo_t::
253 picture_spatial_scalable_extension()
254 {
255   pict_scal = 1; /* use spatial scalability in this picture */
256   lltempref = vstream->get_bits(10);
257   vstream->get_bit_noptr();
258   llx0 = vstream->get_bits(15);
259   if(llx0 >= 16384) llx0 -= 32768;
260   vstream->get_bit_noptr();
261   lly0 = vstream->get_bits(15);
262   if(lly0 >= 16384) lly0 -= 32768;
263   stwc_table_index = vstream->get_bits(2);
264   llprog_frame = vstream->get_bit_noptr();
265   llfieldsel = vstream->get_bit_noptr();
266   return 0;
267 }
268
269
270 /* decode picture temporal scalable extension
271  *
272  * not implemented
273  *
274  */
275
276 int zvideo_t::
277 picture_temporal_scalable_extension()
278 {
279   zerr("temporal scalability not supported\n");
280   return 0;
281 }
282
283
284 /* decode extension and user data */
285
286 int zvideo_t::
287 ext_user_data()
288 {
289   int zcode = vstream->next_start_code();
290   if( zcode < 0 ) return 1;
291   while( zcode == EXT_START_CODE || zcode == USER_START_CODE ) {
292     vstream->refill();
293     if( zcode == EXT_START_CODE ) {
294       int ext_id = vstream->get_bits(4);
295       switch(ext_id) {
296       case ext_id_SEQ:
297         sequence_extension();
298         break;
299       case ext_id_DISP:
300         sequence_display_extension();
301         break;
302       case ext_id_QUANT:
303         quant_matrix_extension();
304         break;
305       case ext_id_SEQSCAL:
306         sequence_scalable_extension();
307         break;
308       case ext_id_PANSCAN:
309         picture_display_extension();
310         break;
311       case ext_id_CODING:
312         picture_coding_extension();
313         break;
314       case ext_id_SPATSCAL:
315         picture_spatial_scalable_extension();
316         break;
317       case ext_id_TEMPSCAL:
318         picture_temporal_scalable_extension();
319         break;
320       default:
321         zerrs("reserved extension start code ID %d\n", ext_id);
322         break;
323       }
324     }
325     else if( subtitle_track >= 0 ) {
326       int32_t id = vstream->show_bits(32);
327       if( id == 0x47413934 ) { /* "GA94" - atsc user data */
328         vstream->refill();
329         int typ = vstream->get_bits(8);
330         if( typ == 3 ) /* mpeg cc */
331           get_cc()->get_atsc_data(vstream);
332       }
333     }
334     zcode = vstream->next_start_code();
335     if( zcode < 0 ) return 1;
336   }
337 //zmsgs("prog_seq=%d prog_frame=%d\n", prog_seq,prog_frame);
338   return 0;
339 }
340
341
342 /* decode group of pictures header */
343
344 int zvideo_t::
345 get_gop_header()
346 {
347 //zmsg("1\n");
348   has_gops = 1;
349   //int drop_flag =
350     vstream->get_bit_noptr();
351   gop_timecode.hour = vstream->get_bits(5);
352   gop_timecode.minute = vstream->get_bits(6);
353   vstream->get_bit_noptr();
354   gop_timecode.second = vstream->get_bits(6);
355   gop_timecode.frame = vstream->get_bits(6);
356   //int closed_gop =
357     vstream->get_bit_noptr();
358   //int broken_link =
359     vstream->get_bit_noptr();
360 //zmsg("100\n");
361 //zmsgs("%d:%d:%d:%d %d %d %d\n",
362 //  gop_timecode.hour, gop_timecode.minute, gop_timecode.second,
363 //  gop_timecode.frame, drop_flag, closed_gop, broken_link);
364   return vstream->error();
365 }
366
367 /* decode picture header */
368
369 int zvideo_t::
370 get_picture_hdr()
371 {
372   pict_scal = 0; /* unless overwritten by pict. spat. scal. ext. */
373   //int temp_ref =
374     vstream->get_bits(10);
375   pict_type = vstream->get_bits(3);
376   //int vbv_delay =
377     vstream->get_bits(16);
378   if( pict_type == pic_type_P || pict_type == pic_type_B ) {
379     full_forw = vstream->get_bit_noptr();
380     forw_r_size = vstream->get_bits(3) - 1;
381   }
382
383   if( pict_type == pic_type_B ) {
384     full_back = vstream->get_bit_noptr();
385     back_r_size = vstream->get_bits(3) - 1;
386   }
387
388 /* get extra bit picture */
389   while( !vstream->eof() && vstream->get_bit_noptr() )
390     vstream->get_bits_noptr(8);
391   return 0;
392 }
393
394
395 /* move to start of header. */
396 /*  this updates the demuxer times */
397 int zvideo_t::
398 find_header()
399 {
400   for( int count=0x1000; --count>=0; ) {
401     int zcode = vstream->next_start_code();
402     if( zcode < 0 ) break;
403     switch(zcode) {
404     case SEQUENCE_START_CODE:
405     case GOP_START_CODE:
406     case PICTURE_START_CODE:
407       return 0;
408     }
409     vstream->refill();
410   }
411
412   return 1;
413 }
414
415
416 int zvideo_t::
417 get_header()
418 {
419 // Stop search after this many start codes
420   for( int count=0x1000; --count>=0; ) {
421 /* look for startcode */
422     int zcode = vstream->next_start_code();
423     if( zcode < 0 ) break;
424     vstream->refill();
425
426     switch(zcode) {
427     case SEQUENCE_START_CODE:
428 /* a sequence header should be found before returning from get_header the */
429 /* first time (this is to set horizontal/vertical size properly) */
430       found_seqhdr = 1;
431       get_seq_hdr();  
432       ext_user_data();
433       break;
434
435     case GOP_START_CODE:
436       get_gop_header();
437       ext_user_data();
438       break;
439
440     case PICTURE_START_CODE:
441       get_picture_hdr();
442       ext_user_data();
443       if( cc ) cc->reorder();
444       if( found_seqhdr )
445         return 0;       /* Exit here */
446       break;
447     }
448   }
449
450   return 1;
451 }
452
453 int zslice_buffer_t::
454 ext_bit_info()
455 {
456   while( get_bit() ) get_bits(8);
457   return 0;
458 }
459
460 /* decode slice header */
461 int zslice_decoder_t::
462 get_slice_hdr()
463 {
464   int slice_vertical_position_extension;
465   int qs;
466   slice_vertical_position_extension =
467     (video->mpeg2 && video->vertical_size>2800) ?
468       slice_buffer->get_bits(3) : 0;
469
470   if( video->scalable_mode == sc_DP )
471     pri_brk = slice_buffer->get_bits(7);
472
473   qs = slice_buffer->get_bits(5);
474   quant_scale = video->mpeg2 ?
475     (video->qscale_type ? non_linear_mquant_table[qs] : (qs << 1)) :
476     qs;
477
478 //int intra_slice = 0;
479   if( slice_buffer->get_bit() ) {
480     //intra_slice =
481       slice_buffer->get_bit();
482     slice_buffer->get_bits(7);
483     slice_buffer->ext_bit_info();
484   }
485
486   return slice_vertical_position_extension;
487 }
488