[cvs] / xvidcore / src / bitstream / bitstream.c Repository:
ViewVC logotype

Diff of /xvidcore/src/bitstream/bitstream.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.28.2.6, Tue Nov 12 15:53:23 2002 UTC revision 1.28.2.7, Sun Dec 8 05:36:20 2002 UTC
# Line 216  Line 216 
216                                  dec->shape == VIDOBJLAY_SHAPE_RECTANGULAR &&                                  dec->shape == VIDOBJLAY_SHAPE_RECTANGULAR &&
217                                  (coding_type == P_VOP || coding_type == I_VOP))                                  (coding_type == P_VOP || coding_type == I_VOP))
218                          {                          {
219                                  BitstreamSkip(bs, 1); /* vop_reduced_resolution */                                  BitstreamSkip(bs, 1); /* XXX: vop_reduced_resolution */
220                          }                          }
221    
222                          if (coding_type != I_VOP && fcode_forward)                          if (coding_type != I_VOP && fcode_forward)
# Line 254  Line 254 
254    
255    
256    
257    
258    /* vol estimation header */
259    static void
260    read_vol_complexity_estimation_header(Bitstream * bs, DECODER * dec)
261    {
262            ESTIMATION * e = &dec->estimation;
263    
264            e->method = BitstreamGetBits(bs, 2);    /* estimation_method */
265            DPRINTF(DPRINTF_HEADER,"+ complexity_estimation_header; method=%i", e->method);
266    
267            if (e->method == 0 || e->method == 1)
268            {
269                    if (!BitstreamGetBit(bs))               /* shape_complexity_estimation_disable */
270                    {
271                            e->opaque = BitstreamGetBit(bs);                /* opaque */
272                            e->transparent = BitstreamGetBit(bs);           /* transparent */
273                            e->intra_cae = BitstreamGetBit(bs);             /* intra_cae */
274                            e->inter_cae = BitstreamGetBit(bs);             /* inter_cae */
275                            e->no_update = BitstreamGetBit(bs);             /* no_update */
276                            e->upsampling = BitstreamGetBit(bs);            /* upsampling */
277                    }
278    
279                    if (!BitstreamGetBit(bs))       /* texture_complexity_estimation_set_1_disable */
280                    {
281                            e->intra_blocks = BitstreamGetBit(bs);          /* intra_blocks */
282                            e->inter_blocks = BitstreamGetBit(bs);          /* inter_blocks */
283                            e->inter4v_blocks = BitstreamGetBit(bs);                /* inter4v_blocks */
284                            e->not_coded_blocks = BitstreamGetBit(bs);              /* not_coded_blocks */
285                    }
286            }
287    
288            READ_MARKER();
289    
290            if (!BitstreamGetBit(bs))               /* texture_complexity_estimation_set_2_disable */
291            {
292                    e->dct_coefs = BitstreamGetBit(bs);             /* dct_coefs */
293                    e->dct_lines = BitstreamGetBit(bs);             /* dct_lines */
294                    e->vlc_symbols = BitstreamGetBit(bs);           /* vlc_symbols */
295                    e->vlc_bits = BitstreamGetBit(bs);              /* vlc_bits */
296            }
297    
298            if (!BitstreamGetBit(bs))               /* motion_compensation_complexity_disable */
299            {
300                    e->apm = BitstreamGetBit(bs);           /* apm */
301                    e->npm = BitstreamGetBit(bs);           /* npm */
302                    e->interpolate_mc_q = BitstreamGetBit(bs);              /* interpolate_mc_q */
303                    e->forw_back_mc_q = BitstreamGetBit(bs);                /* forw_back_mc_q */
304                    e->halfpel2 = BitstreamGetBit(bs);              /* halfpel2 */
305                    e->halfpel4 = BitstreamGetBit(bs);              /* halfpel4 */
306            }
307    
308            READ_MARKER();
309    
310            if (e->method == 1)
311            {
312                    if (!BitstreamGetBit(bs))       /* version2_complexity_estimation_disable */
313                    {
314                            e->sadct = BitstreamGetBit(bs);         /* sadct */
315                            e->quarterpel = BitstreamGetBit(bs);            /* quarterpel */
316                    }
317            }
318    }
319    
320    
321    /* vop estimation header */
322    static void
323    read_vop_complexity_estimation_header(Bitstream * bs, DECODER * dec, int coding_type)
324    {
325            ESTIMATION * e = &dec->estimation;
326    
327            if (e->method == 0)
328            {
329                    if (coding_type == I_VOP) {
330                            if (e->opaque)          BitstreamSkip(bs, 8);   /* dcecs_opaque */
331                            if (e->transparent) BitstreamSkip(bs, 8);       /* */
332                            if (e->intra_cae)       BitstreamSkip(bs, 8);   /* */
333                            if (e->inter_cae)       BitstreamSkip(bs, 8);   /* */
334                            if (e->no_update)       BitstreamSkip(bs, 8);   /* */
335                            if (e->upsampling)      BitstreamSkip(bs, 8);   /* */
336                            if (e->intra_blocks) BitstreamSkip(bs, 8);      /* */
337                            if (e->not_coded_blocks) BitstreamSkip(bs, 8);  /* */
338                            if (e->dct_coefs)       BitstreamSkip(bs, 8);   /* */
339                            if (e->dct_lines)       BitstreamSkip(bs, 8);   /* */
340                            if (e->vlc_symbols) BitstreamSkip(bs, 8);       /* */
341                            if (e->vlc_bits)        BitstreamSkip(bs, 8);   /* */
342                            if (e->sadct)           BitstreamSkip(bs, 8);   /* */
343                    }
344    
345                    if (coding_type == P_VOP) {
346                            if (e->opaque) BitstreamSkip(bs, 8);            /* */
347                            if (e->transparent) BitstreamSkip(bs, 8);       /* */
348                            if (e->intra_cae)       BitstreamSkip(bs, 8);   /* */
349                            if (e->inter_cae)       BitstreamSkip(bs, 8);   /* */
350                            if (e->no_update)       BitstreamSkip(bs, 8);   /* */
351                            if (e->upsampling) BitstreamSkip(bs, 8);        /* */
352                            if (e->intra_blocks) BitstreamSkip(bs, 8);      /* */
353                            if (e->not_coded_blocks)        BitstreamSkip(bs, 8);   /* */
354                            if (e->dct_coefs)       BitstreamSkip(bs, 8);   /* */
355                            if (e->dct_lines)       BitstreamSkip(bs, 8);   /* */
356                            if (e->vlc_symbols) BitstreamSkip(bs, 8);       /* */
357                            if (e->vlc_bits)        BitstreamSkip(bs, 8);   /* */
358                            if (e->inter_blocks) BitstreamSkip(bs, 8);      /* */
359                            if (e->inter4v_blocks) BitstreamSkip(bs, 8);    /* */
360                            if (e->apm)                     BitstreamSkip(bs, 8);   /* */
361                            if (e->npm)                     BitstreamSkip(bs, 8);   /* */
362                            if (e->forw_back_mc_q) BitstreamSkip(bs, 8);    /* */
363                            if (e->halfpel2)        BitstreamSkip(bs, 8);   /* */
364                            if (e->halfpel4)        BitstreamSkip(bs, 8);   /* */
365                            if (e->sadct)           BitstreamSkip(bs, 8);   /* */
366                            if (e->quarterpel)      BitstreamSkip(bs, 8);   /* */
367                    }
368                    if (coding_type == B_VOP) {
369                            if (e->opaque)          BitstreamSkip(bs, 8);   /* */
370                            if (e->transparent)     BitstreamSkip(bs, 8);   /* */
371                            if (e->intra_cae)       BitstreamSkip(bs, 8);   /* */
372                            if (e->inter_cae)       BitstreamSkip(bs, 8);   /* */
373                            if (e->no_update)       BitstreamSkip(bs, 8);   /* */
374                            if (e->upsampling)      BitstreamSkip(bs, 8);   /* */
375                            if (e->intra_blocks) BitstreamSkip(bs, 8);      /* */
376                            if (e->not_coded_blocks) BitstreamSkip(bs, 8);  /* */
377                            if (e->dct_coefs)       BitstreamSkip(bs, 8);   /* */
378                            if (e->dct_lines)       BitstreamSkip(bs, 8);   /* */
379                            if (e->vlc_symbols)     BitstreamSkip(bs, 8);   /* */
380                            if (e->vlc_bits)        BitstreamSkip(bs, 8);   /* */
381                            if (e->inter_blocks) BitstreamSkip(bs, 8);      /* */
382                            if (e->inter4v_blocks) BitstreamSkip(bs, 8);    /* */
383                            if (e->apm)                     BitstreamSkip(bs, 8);   /* */
384                            if (e->npm)                     BitstreamSkip(bs, 8);   /* */
385                            if (e->forw_back_mc_q) BitstreamSkip(bs, 8);    /* */
386                            if (e->halfpel2)        BitstreamSkip(bs, 8);   /* */
387                            if (e->halfpel4)        BitstreamSkip(bs, 8);   /* */
388                            if (e->interpolate_mc_q) BitstreamSkip(bs, 8);  /* */
389                            if (e->sadct)           BitstreamSkip(bs, 8);   /* */
390                            if (e->quarterpel)      BitstreamSkip(bs, 8);   /* */
391                    }
392    
393                    if (coding_type == S_VOP && dec->sprite_enable == SPRITE_STATIC) {
394                            if (e->intra_blocks) BitstreamSkip(bs, 8);      /* */
395                            if (e->not_coded_blocks) BitstreamSkip(bs, 8);  /* */
396                            if (e->dct_coefs)       BitstreamSkip(bs, 8);   /* */
397                            if (e->dct_lines)       BitstreamSkip(bs, 8);   /* */
398                            if (e->vlc_symbols)     BitstreamSkip(bs, 8);   /* */
399                            if (e->vlc_bits)        BitstreamSkip(bs, 8);   /* */
400                            if (e->inter_blocks) BitstreamSkip(bs, 8);      /* */
401                            if (e->inter4v_blocks)  BitstreamSkip(bs, 8);   /* */
402                            if (e->apm)                     BitstreamSkip(bs, 8);   /* */
403                            if (e->npm)                     BitstreamSkip(bs, 8);   /* */
404                            if (e->forw_back_mc_q)  BitstreamSkip(bs, 8);   /* */
405                            if (e->halfpel2)        BitstreamSkip(bs, 8);   /* */
406                            if (e->halfpel4)        BitstreamSkip(bs, 8);   /* */
407                            if (e->interpolate_mc_q) BitstreamSkip(bs, 8);  /* */
408                    }
409            }
410    }
411    
412    
413    
414    
415    
416  /*  /*
417  decode headers  decode headers
418  returns coding_type, or -1 if error  returns coding_type, or -1 if error
# Line 576  Line 735 
735                                          dec->quarterpel = 0;                                          dec->quarterpel = 0;
736    
737    
738                                  if (!BitstreamGetBit(bs))       // complexity_estimation_disable                                  dec->complexity_estimation_disable = BitstreamGetBit(bs);       /* complexity estimation disable */
739                                    if (!dec->complexity_estimation_disable)
740                                  {                                  {
741                                          DPRINTF(DPRINTF_ERROR, "complexity_estimation not supported");                                          read_vol_complexity_estimation_header(bs, dec);
                                         return -1;  
742                                  }                                  }
743    
744                                  BitstreamSkip(bs, 1);   // resync_marker_disable                                  BitstreamSkip(bs, 1);   // resync_marker_disable
# Line 598  Line 757 
757                                                  BitstreamSkip(bs, 2);   // requested_upstream_message_type                                                  BitstreamSkip(bs, 2);   // requested_upstream_message_type
758                                                  BitstreamSkip(bs, 1);   // newpred_segment_type                                                  BitstreamSkip(bs, 1);   // newpred_segment_type
759                                          }                                          }
760                                          dec->reduced_resolution_enable = BitstreamGetBit(bs);                                          dec->reduced_resolution_enable = BitstreamGetBit(bs);   /* reduced_resolution_vop_enable */
761                                          if (dec->reduced_resolution_enable)     // reduced_resolution_vop_enable                                          DPRINTF(DPRINTF_HEADER, "reduced_resolution_enable %i", dec->reduced_resolution_enable);
                                         {  
                                                 DPRINTF(DPRINTF_ERROR, "reduced_resolution_vop not supported");  
                                                 //return -1;  
                                         }  
762                                  }                                  }
763                                  else                                  else
764                                  {                                  {
# Line 611  Line 766 
766                                          dec->reduced_resolution_enable = 0;                                          dec->reduced_resolution_enable = 0;
767                                  }                                  }
768    
769                                  if ((dec->scalability = BitstreamGetBit(bs)))   // scalability                                  dec->scalability = BitstreamGetBit(bs); /* scalability */
770                                    if (dec->scalability)
771                                  {                                  {
772                                          DPRINTF(DPRINTF_ERROR, "scalability not supported");                                          DPRINTF(DPRINTF_ERROR, "scalability not supported");
773                                            BitstreamSkip(bs, 1);   /* hierarchy_type */
774                                            BitstreamSkip(bs, 4);   /* ref_layer_id */
775                                            BitstreamSkip(bs, 1);   /* ref_layer_sampling_direc */
776                                            BitstreamSkip(bs, 5);   /* hor_sampling_factor_n */
777                                            BitstreamSkip(bs, 5);   /* hor_sampling_factor_m */
778                                            BitstreamSkip(bs, 5);   /* vert_sampling_factor_n */
779                                            BitstreamSkip(bs, 5);   /* vert_sampling_factor_m */
780                                            BitstreamSkip(bs, 1);   /* enhancement_type */
781                                            if(dec->shape == VIDOBJLAY_SHAPE_BINARY /* && hierarchy_type==0 */) {
782                                                    BitstreamSkip(bs, 1);   /* use_ref_shape */
783                                                    BitstreamSkip(bs, 1);   /* use_ref_texture */
784                                                    BitstreamSkip(bs, 5);   /* shape_hor_sampling_factor_n */
785                                                    BitstreamSkip(bs, 5);   /* shape_hor_sampling_factor_m */
786                                                    BitstreamSkip(bs, 5);   /* shape_vert_sampling_factor_n */
787                                                    BitstreamSkip(bs, 5);   /* shape_vert_sampling_factor_m */
788                                            }
789                                          return -1;                                          return -1;
790                                  }                                  }
791                          } else                          // dec->shape == BINARY_ONLY                          } else                          // dec->shape == BINARY_ONLY
792                          {                          {
793                                  if (vol_ver_id != 1) {                                  if (vol_ver_id != 1) {
794                                          if (BitstreamGetBit(bs))        // scalability                                          dec->scalability = BitstreamGetBit(bs); /* scalability */
795                                            if (dec->scalability)
796                                          {                                          {
797                                          DPRINTF(DPRINTF_ERROR, "scalability not supported");                                          DPRINTF(DPRINTF_ERROR, "scalability not supported");
798                                                    BitstreamSkip(bs, 4);   /* ref_layer_id */
799                                                    BitstreamSkip(bs, 5);   /* hor_sampling_factor_n */
800                                                    BitstreamSkip(bs, 5);   /* hor_sampling_factor_m */
801                                                    BitstreamSkip(bs, 5);   /* vert_sampling_factor_n */
802                                                    BitstreamSkip(bs, 5);   /* vert_sampling_factor_m */
803                                                  return -1;                                                  return -1;
804                                          }                                          }
805                                  }                                  }
# Line 732  Line 910 
910                                  (coding_type == P_VOP || coding_type == I_VOP)) {                                  (coding_type == P_VOP || coding_type == I_VOP)) {
911    
912                                  *reduced_resolution = BitstreamGetBit(bs);                                  *reduced_resolution = BitstreamGetBit(bs);
913                                    DPRINTF(DPRINTF_HEADER, "reduced_resolution %i", *reduced_resolution);
914                          }                          }
915                          else                          else
916                          {                          {
# Line 767  Line 946 
946                          }                          }
947    
948                          if (dec->shape != VIDOBJLAY_SHAPE_BINARY_ONLY) {                          if (dec->shape != VIDOBJLAY_SHAPE_BINARY_ONLY) {
949    
950                                    if (!dec->complexity_estimation_disable)
951                                    {
952                                            read_vop_complexity_estimation_header(bs, dec, coding_type);
953                                    }
954    
955                                  // intra_dc_vlc_threshold                                  // intra_dc_vlc_threshold
956                                  *intra_dc_threshold =                                  *intra_dc_threshold =
957                                          intra_dc_threshold_table[BitstreamGetBits(bs, 3)];                                          intra_dc_threshold_table[BitstreamGetBits(bs, 3)];
# Line 849  Line 1034 
1034    
1035                  } else if (start_code == USERDATA_START_CODE) {                  } else if (start_code == USERDATA_START_CODE) {
1036                          char tmp[256];                          char tmp[256];
1037                      int i;                      int i, version, build, packed;
1038    
1039                          BitstreamSkip(bs, 32);  // user_data_start_code                          BitstreamSkip(bs, 32);  // user_data_start_code
1040    
# Line 866  Line 1051 
1051    
1052                          DPRINTF(DPRINTF_STARTCODE, "<user_data>: %s\n", tmp);                          DPRINTF(DPRINTF_STARTCODE, "<user_data>: %s\n", tmp);
1053    
1054                          if(strncmp(tmp, "DivX501b481p", 12) == 0) {                      /* divx detection */
1055                                  dec->packed_mode = 1;                          i = sscanf(tmp, "DivX%dBuild%d%c", &version, &build, &packed);
1056                                  DPRINTF(DPRINTF_STARTCODE, "packed_mode = %d\n", dec->packed_mode);                          if (i < 2)
1057                                    i = sscanf(tmp, "DivX%db%d%c", &version, &build, &packed);
1058    
1059                            if (i >= 2)
1060                            {
1061                                    dec->packed_mode = (i == 3 && packed == 'p');
1062                                    DPRINTF(DPRINTF_HEADER, "divx version=%i, build=%i packed=%i",
1063                                                    version, build, dec->packed_mode);
1064                          }                          }
1065    
1066                  } else                                  // start_code == ?                  } else                                  // start_code == ?
1067                  {                  {
1068                          if (BitstreamShowBits(bs, 24) == 0x000001) {                          if (BitstreamShowBits(bs, 24) == 0x000001) {
# Line 1123  Line 1315 
1315                  // no support for brightness_change!                  // no support for brightness_change!
1316          }          }
1317    
1318    
1319            DPRINTF(DPRINTF_HEADER, "quant = %i", frame->quant);
1320    
1321          BitstreamPutBits(bs, frame->quant, 5);  // quantizer          BitstreamPutBits(bs, frame->quant, 5);  // quantizer
1322    
1323          if (frame->coding_type != I_VOP)          if (frame->coding_type != I_VOP)

Legend:
Removed from v.1.28.2.6  
changed lines
  Added in v.1.28.2.7

No admin address has been configured
ViewVC Help
Powered by ViewVC 1.0.4