root/vic/branches/mpeg4/codec/tmndec/gethdr.c @ 4155

Revision 4155, 23.8 KB (checked in by piers, 6 years ago)

Patched these files so symbols don't clash with ffmpeg when the following libraries are built: libxvidcore.a and libmp3lame.a. Patch submitted by Brook Milligan 8nov07 - I patched them a while back but only just committed them.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/************************************************************************
2 *
3 *  gethdr.c, header decoding for tmndecode (H.263 decoder)
4 *  Copyright (C) 1995, 1996  Telenor R&D, Norway
5 *
6 *  Contacts:
7 *  Robert Danielsen                  <Robert.Danielsen@nta.no>
8 *
9 *  Telenor Research and Development  http://www.nta.no/brukere/DVC/
10 *  P.O.Box 83                        tel.:   +47 63 84 84 00
11 *  N-2007 Kjeller, Norway            fax.:   +47 63 81 00 76
12 *
13 *  Copyright (C) 1997  University of BC, Canada
14 *  Modified by: Michael Gallant <mikeg@ee.ubc.ca>
15 *               Guy Cote <guyc@ee.ubc.ca>
16 *               Berna Erol <bernae@ee.ubc.ca>
17 *
18 *  Contacts:
19 *  Michael Gallant                   <mikeg@ee.ubc.ca>
20 *
21 *  UBC Image Processing Laboratory   http://www.ee.ubc.ca/image
22 *  2356 Main Mall                    tel.: +1 604 822 4051
23 *  Vancouver BC Canada V6T1Z4        fax.: +1 604 822 5949
24 *
25 ************************************************************************/
26
27/* Disclaimer of Warranty
28 *
29 * These software programs are available to the user without any license fee
30 * or royalty on an "as is" basis. The University of British Columbia
31 * disclaims any and all warranties, whether express, implied, or
32 * statuary, including any implied warranties or merchantability or of
33 * fitness for a particular purpose.  In no event shall the
34 * copyright-holder be liable for any incidental, punitive, or
35 * consequential damages of any kind whatsoever arising from the use of
36 * these programs.
37 *
38 * This disclaimer of warranty extends to the user of these programs and
39 * user's customers, employees, agents, transferees, successors, and
40 * assigns.
41 *
42 * The University of British Columbia does not represent or warrant that the
43 * programs furnished hereunder are free of infringement of any
44 * third-party patents.
45 *
46 * Commercial implementations of H.263, including shareware, are subject to
47 * royalty fees to patent holders.  Many of these patents are general
48 * enough such that they are unavoidable regardless of implementation
49 * design.
50 *
51 */
52
53
54/* modified to support annex O true B frames, mikeg@ee.ubc.ca
55 *
56 * modified to support general H.263+ syntax, bernae@ee.ubc.ca
57 *
58 * based on mpeg2decode, (C) 1994, MPEG Software Simulation Group and
59 * mpeg2play, (C) 1994 Stefan Eckart <stefan@lis.e-technik.tu-muenchen.de> */
60
61
62#include <stdio.h>
63#include <stdlib.h>
64
65#include "config.h"
66#include "tmndec.h"
67#include "global.h"
68
69/* private prototypes */
70static void getpicturehdr _ANSI_ARGS_ ((void));
71
72/* decode headers from one input stream until an End of Sequence or
73 * picture start code is found */
74
75int getheader ()
76{
77  unsigned int code, gob;
78
79  /* look for startcode */
80  startcode ();
81  code = vic_getbits (PSC_LENGTH);
82  gob = vic_getbits (5);
83  if (gob == SE_CODE)
84    return 0;
85  if (gob == 0)
86  {
87    if (trace)
88    {
89
90      fprintf (trace_file, "\nPSC: ");
91      printbits ((code << (5 + gob)), 22, 22);
92    }
93    getpicturehdr ();
94    if (syntax_arith_coding)    /* reset decoder after receiving */
95      decoder_reset ();         /* fixed length PSC string */
96  }
97  else
98  {
99    if (trace)
100    {
101
102      fprintf (trace_file, "\nGBSC: ");
103      printbits ((code << (5 + gob)), 22, 22);
104    }
105  }
106  return gob + 1;
107}
108
109
110/* align to start of next startcode */
111
112void startcode ()
113{
114  /* search for new picture start code */
115  while (showbits (PSC_LENGTH) != 1l)
116    flushbits (1);
117}
118
119/* decode picture header */
120
121static void getpicturehdr ()
122{
123  int pos, pei, tmp;
124  int UFEP = 0;
125  int BCI = 0;
126  int clock_conversion_code = 0;
127  int clock_divisor = 0;
128  int extended_temporal_reference = 0;
129  int prev_plus_P_temp_ref = 0;
130
131  pos = ld->bitcnt;
132
133  prev_plus_P_temp_ref = temp_ref;
134  temp_ref = vic_getbits (8);
135  if (trace)
136  {
137    fprintf (trace_file, "\nTR: ");
138    printbits (temp_ref, 8, 8);
139  }
140  if (trd < 0)
141    trd += 256;
142
143  tmp = vic_getbits (1);            /* always "1" */
144  if (trace)
145    fprintf (trace_file, "\nSpare: %d", tmp);
146  if (!tmp)
147    if (!quiet)
148      printf ("warning: spare in picture header should be \"1\"\n");
149  tmp = vic_getbits (1);            /* always "0" */
150  if (trace)
151    fprintf (trace_file, "\nH.261 distinction bit: %d", tmp);
152  if (tmp)
153    if (!quiet)
154      printf ("warning: H.261 distinction bit should be \"0\"\n");
155  tmp = vic_getbits (1);            /* split_screen_indicator */
156  if (trace)
157    fprintf (trace_file, "\nsplit_screen_indicator: %d", tmp);
158  if (tmp)
159  {
160    if (!quiet)
161      printf ("error: split-screen not supported in this version\n");
162    exit (-1);
163  }
164  tmp = vic_getbits (1);            /* document_camera_indicator */
165  if (trace)
166    fprintf (trace_file, "\ndocument_camera_indicator: %d", tmp);
167  if (tmp)
168    if (!quiet)
169      printf ("warning: document camera indicator not supported in this version\n");
170
171  tmp = vic_getbits (1);            /* freeze_picture_release */
172  if (trace)
173    fprintf (trace_file, "\nfreeze_picture_release: %d", tmp);
174  if (tmp)
175    if (!quiet)
176      printf ("warning: frozen picture not supported in this version\n");
177  tmp = vic_getbits (3);
178  if (trace)
179  {
180    fprintf (trace_file, "\nsource_format: ");
181    printbits (tmp, 3, 3);
182  }
183
184  if (tmp == EXTENDED_PTYPE)
185  {
186    if (trace)
187      fprintf (trace_file, "\n----------EXTENDED_PTYPE----------");
188    plus_type = 1;
189    UFEP = vic_getbits (3);
190    if (trace)
191    {
192      fprintf (trace_file, "\nUFEP: ");
193      printbits (UFEP, 3, 3);
194    }
195    if (UFEP == 1)
196    {                           /* OPPTYPE */
197      if (trace)
198        fprintf (trace_file, "\n----------OPTIONAL PLUS PTYPE----------");
199      source_format_old = source_format;
200      source_format = vic_getbits (3);
201      if (trace)
202      {
203        fprintf (trace_file, "\nsource_format: ");
204        printbits (source_format, 3, 3);
205      }
206   
207      /* optional custom picture clock frequency */
208      optional_custom_PCF = vic_getbits (1);
209      if (trace)
210      {
211        fprintf (trace_file, "\noptional_custom_PCF: ");
212        printbits (optional_custom_PCF, 1, 1);
213      }
214      if (optional_custom_PCF)
215      {
216        if (!quiet)
217          printf ("error: Optional custom picture clock frequency is not supported in this version\n");
218        exit (-1);
219      }
220      mv_outside_frame = vic_getbits (1);
221      if (trace)
222      {
223        fprintf (trace_file, "\nmv_outside_frame: ");
224        printbits (mv_outside_frame, 1, 1);
225      }
226      long_vectors = (mv_outside_frame ? 1 : 0);
227      syntax_arith_coding = vic_getbits (1);
228      if (trace)
229      {
230        fprintf (trace_file, "\nsyntax_arith_coding: ");
231        printbits (syntax_arith_coding, 1, 1);
232      }
233      adv_pred_mode = vic_getbits (1);
234      if (trace)
235      {
236        fprintf (trace_file, "\nadv_pred_mode: ");
237        printbits (adv_pred_mode, 1, 1);
238      }
239      mv_outside_frame = (adv_pred_mode ? 1 : mv_outside_frame);
240      overlapping_MC = (adv_pred_mode ? 1 : 0);
241      use_4mv = (adv_pred_mode ? 1 : 0);
242      pb_frame = 0;
243      advanced_intra_coding = vic_getbits (1);
244      if (trace)
245      {
246        fprintf (trace_file, "\nadvanced_intra_coding: ");
247        printbits (advanced_intra_coding, 1, 1);
248      }
249      deblocking_filter_mode = vic_getbits (1);
250      if (trace)
251      {
252        fprintf (trace_file, "\ndeblocking_filter_mode: ");
253        printbits (deblocking_filter_mode, 1, 1);
254      }
255      mv_outside_frame = (deblocking_filter_mode ? 1 : mv_outside_frame);
256      use_4mv = (deblocking_filter_mode ? 1 : use_4mv);
257
258      slice_structured_mode = vic_getbits (1);
259      if (trace)
260      {
261        fprintf (trace_file, "\nslice_structured_mode: ");
262        printbits (slice_structured_mode, 1, 1);
263      }
264      if (slice_structured_mode)
265      {
266        if (!quiet)
267          printf ("error: Slice structured mode is not supported in this version\n");
268        exit (-1);
269      }
270      reference_picture_selection_mode = vic_getbits (1);
271      if (trace)
272      {
273        fprintf (trace_file, "\nreference_picture_selection_mode: ");
274        printbits (reference_picture_selection_mode, 1, 1);
275      }
276#if 0
277      if (reference_picture_selection_mode)
278      {
279        if (!quiet)
280          printf ("error: Reference picture selection mode is not supported in this version\n");
281        exit (-1);
282      }
283#endif
284      independently_segmented_decoding_mode = vic_getbits (1);
285      if (trace)
286      {
287        fprintf (trace_file, "\nindependently_segmented_decoding_mode: ");
288        printbits (independently_segmented_decoding_mode, 1, 1);
289      }
290      if (independently_segmented_decoding_mode)
291      {
292        if (!quiet)
293          printf ("error: Independently segmented decoding mode is not supported in this version\n");
294        exit (-1);
295      }
296      alternative_inter_VLC_mode = vic_getbits (1);
297      if (trace)
298      {
299        fprintf (trace_file, "\nalternative_inter_VLC_mode: ");
300        printbits (alternative_inter_VLC_mode, 1, 1);
301      }
302      modified_quantization_mode = vic_getbits (1);
303      if (trace)
304      {
305        fprintf (trace_file, "\nmodified_quantization_mode: ");
306        printbits (modified_quantization_mode, 1, 1);
307      }
308      tmp = vic_getbits (4);
309      if (trace)
310      {
311        fprintf (trace_file, "\nspare, reserve, reserve, reserve: ");
312        printbits (tmp, 4, 4);
313      }
314      if (tmp != 8)
315      {                         /* OPPTYPE : bit15=1, bit16,bit17,bit18=0 */
316        if (!quiet)
317          printf ("error: The last 4 bits of OPPTYPE is expected to be 1000\n");
318        exit (-1);
319      }
320    }
321    if ((UFEP == 1) || (UFEP == 0))
322    {
323      if (UFEP == 0)
324      {
325        if (scalability_mode >= 3)
326        {
327          horizontal_size = lines[base_source_format];
328          vertical_size = pels[base_source_format];
329
330          mb_width = horizontal_size / 16;
331          mb_height = vertical_size / 16;
332
333          /* Need to store previous (reference layer) values
334           * for interpolation purposes, as the new values,
335           * i.e. of the spatially scaled layer, depend on
336           * the type of spatial scalability in use. */
337          ref_coded_picture_width = coded_picture_width = horizontal_size;
338          ref_coded_picture_height = coded_picture_height = vertical_size;
339          ref_chrom_width = chrom_width = coded_picture_width >> 1;
340          ref_chrom_height = chrom_height = coded_picture_height >> 1;
341
342          source_format = base_source_format;
343        }
344      }
345
346      /* MMPTYPE */
347      if (trace)
348        fprintf (trace_file, "\n----------MANDATORY PLUS PTYPE----------");
349      pict_type = vic_getbits (3);
350      if (trace)
351      {
352        fprintf (trace_file, "\npict_type: ");
353        printbits (pict_type, 3, 3);
354      }
355      if (pict_type == PCT_IPB)
356        pb_frame = IM_PB_FRAMES;
357      else
358        pb_frame = 0;
359
360      if (PCT_B == pict_type)
361      {
362        true_B_frame = ON;
363        /* Allow motion over picture boundaries, regardless of whether or
364         * not UMV is turned on. */
365        mv_outside_frame = 1;
366        true_b_trb = temp_ref - prev_non_disposable_temp_ref;
367      } else
368      {
369        true_B_frame = OFF;
370        prev_non_disposable_temp_ref = next_non_disposable_temp_ref;
371        next_non_disposable_temp_ref = temp_ref;
372        trd = temp_ref - prev_non_disposable_temp_ref;
373      }
374
375      reference_picture_resampling_mode = vic_getbits (1);
376      if (trace)
377      {
378        fprintf (trace_file, "\nreference_picture_resampling_mode: ");
379        printbits (reference_picture_resampling_mode, 1, 1);
380      }
381      if (reference_picture_resampling_mode)
382      {
383        if (!quiet)
384          printf ("error: Reference picture resampling mode is not supported in this version\n");
385        exit (-1);
386      }
387      reduced_resolution_update_mode = vic_getbits (1);
388      if (trace)
389      {
390        fprintf (trace_file, "\nreduced_resolution_update_mode: ");
391        printbits (reduced_resolution_update_mode, 1, 1);
392      }
393      if (reduced_resolution_update_mode)
394      {
395        if (!quiet)
396          printf ("error: Reduced resolution update mode is not supported in this version\n");
397        exit (-1);
398      }
399      rtype = vic_getbits (1);      /* rounding type */
400      if (trace)
401      {
402        fprintf (trace_file, "\nrounding_type: ");
403        printbits (rtype, 1, 1);
404      }
405      if (trace)
406      {
407        fprintf (trace_file, "\nrtype: ");
408        printbits (rtype, 1, 1);
409      }
410      tmp = vic_getbits (3);
411      if (trace)
412      {
413        fprintf (trace_file, "\nreserve, reserve, spare: ");
414        printbits (tmp, 3, 3);
415      }
416      if (tmp != 1)
417      {                         /* MPPTYPE : bit7,bit8=0  bit9=1 */
418        if (!quiet)
419          exit (-1);
420      }
421    } else
422    {
423      /* UFEP is neither 001 nor 000 */
424      if (!quiet)
425        printf ("error: UFEP should be either 001 or 000.\n");
426      exit (-1);
427    }
428
429    tmp = vic_getbits (1);
430    if (trace)
431    {
432      fprintf (trace_file, "\nCPM: ");
433      printbits (tmp, 5, 5);
434    }
435    if (tmp)
436    {
437      if (!quiet)
438        printf ("error: CPM not supported in this version\n");
439      exit (-1);
440    }
441 
442    if (UFEP && (source_format == SF_CUSTOM))
443    {
444      /* Read custom picture format */
445      if (trace)
446        fprintf (trace_file, "\ncustom picture format \n");
447      CP_PAR_code = vic_getbits (4);
448      if (trace)
449      {
450        fprintf (trace_file, "\nCP_PAR_code: ");
451        printbits (CP_PAR_code, 4, 4);
452      }
453      if (CP_PAR_code != PAR_CIF)
454      {
455        if (!quiet)
456        {
457          printf ("error: only 12:11 pixel aspect ratio supported ");
458        }
459        exit(-1);
460      }
461      tmp=vic_getbits (9);
462      horizontal_size = (tmp + 1 ) * 4;
463      if (trace)
464      {
465        fprintf (trace_file, "\nCP_picture_width_indication: ");
466        printbits (tmp, 9, 9);
467      }
468      tmp = vic_getbits (1);
469      if (trace)
470      {
471        fprintf (trace_file, "\nspare: ");
472        printbits (tmp, 1, 1);
473      }
474      if (!tmp)
475      {
476        if (!quiet)
477          printf ("error: The 14th bit of Custom Picture Format(CPFMT) should be 1\n");
478        exit (-1);
479      }
480      tmp = vic_getbits (8);
481      vertical_size = tmp * 4;
482      if (trace)
483      {
484        fprintf (trace_file, "\nCP_picture_height_indication: ");
485        printbits (tmp, 8, 8);
486      }
487      if ((horizontal_size%16) || (vertical_size%16))
488      {
489        if(!quiet)
490        {
491          printf ("error: only factor of 16 custom source format supported\n");
492        }
493        exit (-1);
494      }
495
496      if (CP_PAR_code == EXTENDED_PAR)
497      {
498        PAR_width = vic_getbits (8);
499        PAR_height = vic_getbits (8);
500      }
501    }
502
503    if (source_format != SF_CUSTOM)
504    {
505        horizontal_size = lines[source_format];
506        vertical_size = pels[source_format];
507
508    }
509   
510    mb_width = horizontal_size / 16;
511    mb_height = vertical_size / 16;
512
513   /* Need to store previous (reference layer) values
514    * for interpolation purposes, as the new values,
515    * i.e. of the spatially scaled layer, depend on
516    * the type of spatial scalability in use. */
517    ref_coded_picture_width = coded_picture_width;
518    coded_picture_width = horizontal_size;
519
520    ref_coded_picture_height = coded_picture_height;
521    coded_picture_height = vertical_size;
522
523    ref_chrom_width = chrom_width;
524    chrom_width = coded_picture_width >> 1;
525
526    ref_chrom_height = chrom_height;
527    chrom_height = coded_picture_height >> 1;
528   
529    if (optional_custom_PCF)
530    {
531      if (trace)
532        fprintf (trace_file, "\noptional_custom_PCF \n");
533      if (UFEP)
534      {
535        clock_conversion_code = vic_getbits (1);
536        if (trace)
537        {
538          fprintf (trace_file, "\nclock_conversion_code: ");
539          printbits (clock_conversion_code, 1, 1);
540        }
541        clock_divisor = vic_getbits (7);
542        if (trace)
543        {
544          fprintf (trace_file, "\nclock_divisor: ");
545          printbits (clock_divisor, 7, 7);
546        }
547        CP_clock_frequency = (int) (1800 / ((float) clock_divisor * (8 + clock_conversion_code)) * 1000);
548      }
549      /* regardless of the value of UFEP */
550      extended_temporal_reference = vic_getbits (2);
551      if (trace)
552      {
553        fprintf (trace_file, "\nextended_temporal_reference: ");
554        printbits (extended_temporal_reference, 2, 2);
555      }
556      temp_ref = extended_temporal_reference << (8 + temp_ref);
557
558      if (PCT_B == pict_type)
559      {
560        true_b_trb = temp_ref - prev_non_disposable_temp_ref;
561      } else
562      {
563        trd = temp_ref - prev_non_disposable_temp_ref;
564      }
565
566      if (trd < 0)
567        trd += 1024;
568    }
569    if (UFEP && slice_structured_mode)
570    {
571      SSS_rectangular_slices = vic_getbits (1);
572      if (trace)
573      {
574        fprintf (trace_file, "\nSSS_rectangular_slices: ");
575        printbits (SSS_rectangular_slices, 1, 1);
576      }
577      SSS_arbitary_slice_ordering = vic_getbits (1);
578      if (trace)
579      {
580        fprintf (trace_file, "\nSSS_arbitary_slice_ordering: ");
581        printbits (SSS_arbitary_slice_ordering, 1, 1);
582      }
583    }
584
585    if ((pict_type == PCT_B) || (pict_type == PCT_EI) || (pict_type == PCT_EP))
586    {
587      /* optional temporal, SNR and spatial scalability mode in use */
588      enhancement_layer_num = vic_getbits (4);
589      if (trace)
590      {
591        fprintf (trace_file, "\nenhancement_layer_num: ");
592        printbits (enhancement_layer_num, 4, 4);
593      }
594      if (UFEP)
595      {
596        reference_layer_number = vic_getbits (4);
597        if (trace)
598        {
599          fprintf (trace_file, "\nreference_layer_number: ");
600          printbits (reference_layer_number, 4, 4);
601        }
602      }
603      if (1 != enhancement_layer_num)
604      {
605        if (source_format != source_format_old)
606        {
607          if (source_format != SF_CUSTOM)
608          {
609            scalability_mode = SPATIAL_SCALABILITY_HV;
610          }
611          else if (coded_picture_width != ref_coded_picture_width)
612          {
613            scalability_mode = SPATIAL_SCALABILITY_H;
614          }
615          else 
616          {
617            scalability_mode = SPATIAL_SCALABILITY_V;
618          }
619        }
620        else
621        {
622          scalability_mode = SNR_SCALABILITY;
623        }
624      }   
625    }
626    else
627    {
628      enhancement_layer_num = reference_layer_number = 1;
629    }
630
631    if (reference_picture_selection_mode)
632    {
633      if (UFEP)
634      {
635        MF_of_reference_picture_selection = vic_getbits (3);
636        if (trace)
637        {
638          fprintf (trace_file, "\nMF_of_reference_picture_selection: ");
639          printbits (MF_of_reference_picture_selection, 3, 3);
640        }
641      }
642      TRPI = vic_getbits (1);
643      if (trace)
644      {
645        fprintf (trace_file, "\nTRPI: ");
646        printbits (TRPI, 1, 1);
647      }
648      if (TRPI)
649      {
650        /* temporal reference for prediction exists */
651        temporal_reference_for_prediction = vic_getbits (10);
652        if (trace)
653        {
654          fprintf (trace_file, "\ntemporal_reference_for_prediction: ");
655          printbits (temporal_reference_for_prediction, 10, 10);
656        }
657      }
658      /* draft20: 1=yes, 01=no */
659      BCI = vic_getbits (1);
660      if (!BCI) vic_getbits(1);
661      if (trace)
662      {
663        fprintf (trace_file, "\nBCI: ");
664        printbits (BCI, 1, 1);
665      }
666      if (BCI)
667      {
668        /* backward channel message exists */
669        /* BCM(backward channel message) is not implemented */
670        if (!quiet)
671          printf ("error: BCM(backward channel message) is not implemented in this version\n");
672        exit (-1);
673      }
674    }
675    if (reference_picture_resampling_mode) {
676      /* reading RPRP info is not implemented */
677      if (!quiet)
678        printf ("error: RPRP reading is not implemented in this version\n");
679      exit (-1);
680    }
681
682    pic_quant = vic_getbits (5);
683    quant = pic_quant;
684
685    if (trace)
686    {
687      fprintf (trace_file, "\nquant: ");
688      printbits (quant, 5, 5);
689    }
690  }
691  else
692  {
693    plus_type = 0;
694    source_format = tmp;
695    enhancement_layer_num = reference_layer_number = 1;
696
697    horizontal_size = lines[source_format];
698    vertical_size = pels[source_format];
699
700    mb_width = horizontal_size / 16;
701    mb_height = vertical_size / 16;
702
703    /* Need to store previous (reference layer) values
704     * for interpolation purposes, as the new values,
705     * i.e. of the spatially scaled layer, depend on
706     * the type of spatial scalability in use. */
707    ref_coded_picture_width = coded_picture_width = horizontal_size;
708    ref_coded_picture_height = coded_picture_height = vertical_size;
709    ref_chrom_width = chrom_width = coded_picture_width >> 1;
710    ref_chrom_height = chrom_height = coded_picture_height >> 1;
711
712    trd = temp_ref - prev_plus_P_temp_ref;
713
714    pict_type = vic_getbits (1);
715    if (trace)
716    {
717      fprintf (trace_file, "\npict_type: ");
718      printbits (pict_type, 1, 1);
719    }
720    mv_outside_frame = vic_getbits (1);
721    if (trace)
722    {
723      fprintf (trace_file, "\nmv_outside_frame: ");
724      printbits (mv_outside_frame, 1, 1);
725    }
726    long_vectors = (mv_outside_frame ? 1 : 0);
727    syntax_arith_coding = vic_getbits (1);
728    if (trace)
729    {
730      fprintf (trace_file, "\nsyntax_arith_coding: ");
731      printbits (syntax_arith_coding, 1, 1);
732    }
733    adv_pred_mode = vic_getbits (1);
734    if (trace)
735    {
736      fprintf (trace_file, "\nadv_pred_mode: ");
737      printbits (adv_pred_mode, 1, 1);
738    }
739    mv_outside_frame = (adv_pred_mode ? 1 : mv_outside_frame);
740    overlapping_MC = (adv_pred_mode ? 1 : 0);
741    use_4mv = (adv_pred_mode ? 1 : 0);
742    pb_frame = vic_getbits (1);
743    if (trace)
744    {
745      fprintf (trace_file, "\npb_frame: ");
746      printbits (pb_frame, 1, 1);
747    }
748   
749    pic_quant = vic_getbits (5);
750    quant = pic_quant;
751
752    if (trace)
753    {
754      fprintf (trace_file, "\nquant: ");
755      printbits (quant, 5, 5);
756    }
757
758    tmp = vic_getbits (1);
759    if (trace)
760    {
761      fprintf (trace_file, "\nCPM: ");
762      printbits (tmp, 5, 5);
763    }
764    if (tmp)
765    {
766      if (!quiet)
767        printf ("error: CPM not supported in this version\n");
768      exit (-1);
769    }
770  }
771
772  if (pb_frame)
773  {
774    if (optional_custom_PCF)
775    {
776      trb = vic_getbits (5);
777      if (trace)
778      {
779        fprintf (trace_file, "\ntrb: ");
780        printbits (trb, 5, 5);
781      }
782    } else
783    {
784      trb = vic_getbits (3);
785      if (trace)
786      {
787        fprintf (trace_file, "\ntrb: ");
788        printbits (trb, 3, 3);
789      }
790    }
791
792    bquant = vic_getbits (2);
793    if (trace)
794    {
795      fprintf (trace_file, "\nbquant: ");
796      printbits (bquant, 2, 2);
797    }
798  } else
799  {
800    trb = 0;
801  }
802
803#ifdef USE_TIME
804  if (framerate > 0 && trd > 0)
805    doframerate (0);
806#endif
807
808  pei = vic_getbits (1);
809  if (trace)
810  {
811    fprintf (trace_file, "\npei: ");
812    printbits (pei, 1, 1);
813  }
814
815pspare:
816  if (pei)
817  {
818    /* extra info for possible future backward compatible additions */
819    vic_getbits (8);                /* not used */
820    pei = vic_getbits (1);
821    if (pei)
822      goto pspare;              /* keep on reading pspare until pei=0 */
823  }
824  if (verbose > 0)
825  {
826    /* $printf("picture header (byte %d)\n",(pos>>3)-4);$ */
827    if (verbose > 1)
828    {
829      printf ("  temp_ref=%d\n", temp_ref);
830      /* $printf("  pict_type=%d\n",pict_type); printf("
831       * source_format=%d\n", source_format); printf("
832       * quant=%d\n",quant); if (syntax_arith_coding) printf("  SAC coding
833       * mode used \n"); if (mv_outside_frame) printf("  unrestricted
834       * motion vector mode used\n"); if (adv_pred_mode) printf("
835       * advanced prediction mode used\n");$ */
836      if (pb_frame)
837      {
838        /* $printf("  pb-frames mode used\n");$ */
839        printf ("  trb=%d\n", trb);
840        /* $printf("  bquant=%d\n", bquant);$ */
841      }
842    }
843  }
844  if (trace)
845  {
846    fprintf (trace_file, "\n--------------------------------------------------------\n");
847  }
848}
849
850void initoptions ()
851{
852  mv_outside_frame = 0;
853  syntax_arith_coding = 0;
854  adv_pred_mode = 0;
855  pb_frame = 0;
856  long_vectors = 0;
857
858  plus_type = 0;
859  optional_custom_PCF = 0;
860  advanced_intra_coding = 0;
861  deblocking_filter_mode = 0;
862  slice_structured_mode = 0;
863  reference_picture_selection_mode = 0;
864  independently_segmented_decoding_mode = 0;
865  alternative_inter_VLC_mode = 0;
866  modified_quantization_mode = 0;
867  reduced_resolution_update_mode = 0;
868  reference_picture_resampling_mode = 0;
869  rtype = 0;
870}
Note: See TracBrowser for help on using the browser.