[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.10, Thu Dec 12 10:37:44 2002 UTC
# Line 77  Line 77 
77  log2bin(uint32_t value)  log2bin(uint32_t value)
78  {  {
79  /* Changed by Chenm001 */  /* Changed by Chenm001 */
80  #ifndef WIN32  #if !defined(_MSC_VER)
81          int n = 0;          int n = 0;
82    
83          while (value) {          while (value) {
# 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 409  Line 568 
568                                          BitstreamSkip(bs, 15);  // latter_half_vbv_occupancy                                          BitstreamSkip(bs, 15);  // latter_half_vbv_occupancy
569                                          READ_MARKER();                                          READ_MARKER();
570                                  }                                  }
571                            }else{
572                                    dec->low_delay = dec->low_delay_default;
573                          }                          }
574    
575                          dec->shape = BitstreamGetBits(bs, 2);   // video_object_layer_shape                          dec->shape = BitstreamGetBits(bs, 2);   // video_object_layer_shape
# Line 576  Line 737 
737                                          dec->quarterpel = 0;                                          dec->quarterpel = 0;
738    
739    
740                                  if (!BitstreamGetBit(bs))       // complexity_estimation_disable                                  dec->complexity_estimation_disable = BitstreamGetBit(bs);       /* complexity estimation disable */
741                                    if (!dec->complexity_estimation_disable)
742                                  {                                  {
743                                          DPRINTF(DPRINTF_ERROR, "complexity_estimation not supported");                                          read_vol_complexity_estimation_header(bs, dec);
                                         return -1;  
744                                  }                                  }
745    
746                                  BitstreamSkip(bs, 1);   // resync_marker_disable                                  BitstreamSkip(bs, 1);   // resync_marker_disable
# Line 598  Line 759 
759                                                  BitstreamSkip(bs, 2);   // requested_upstream_message_type                                                  BitstreamSkip(bs, 2);   // requested_upstream_message_type
760                                                  BitstreamSkip(bs, 1);   // newpred_segment_type                                                  BitstreamSkip(bs, 1);   // newpred_segment_type
761                                          }                                          }
762                                          dec->reduced_resolution_enable = BitstreamGetBit(bs);                                          dec->reduced_resolution_enable = BitstreamGetBit(bs);   /* reduced_resolution_vop_enable */
763                                          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;  
                                         }  
764                                  }                                  }
765                                  else                                  else
766                                  {                                  {
# Line 611  Line 768 
768                                          dec->reduced_resolution_enable = 0;                                          dec->reduced_resolution_enable = 0;
769                                  }                                  }
770    
771                                  if ((dec->scalability = BitstreamGetBit(bs)))   // scalability                                  dec->scalability = BitstreamGetBit(bs); /* scalability */
772                                    if (dec->scalability)
773                                  {                                  {
774                                          DPRINTF(DPRINTF_ERROR, "scalability not supported");                                          DPRINTF(DPRINTF_ERROR, "scalability not supported");
775                                            BitstreamSkip(bs, 1);   /* hierarchy_type */
776                                            BitstreamSkip(bs, 4);   /* ref_layer_id */
777                                            BitstreamSkip(bs, 1);   /* ref_layer_sampling_direc */
778                                            BitstreamSkip(bs, 5);   /* hor_sampling_factor_n */
779                                            BitstreamSkip(bs, 5);   /* hor_sampling_factor_m */
780                                            BitstreamSkip(bs, 5);   /* vert_sampling_factor_n */
781                                            BitstreamSkip(bs, 5);   /* vert_sampling_factor_m */
782                                            BitstreamSkip(bs, 1);   /* enhancement_type */
783                                            if(dec->shape == VIDOBJLAY_SHAPE_BINARY /* && hierarchy_type==0 */) {
784                                                    BitstreamSkip(bs, 1);   /* use_ref_shape */
785                                                    BitstreamSkip(bs, 1);   /* use_ref_texture */
786                                                    BitstreamSkip(bs, 5);   /* shape_hor_sampling_factor_n */
787                                                    BitstreamSkip(bs, 5);   /* shape_hor_sampling_factor_m */
788                                                    BitstreamSkip(bs, 5);   /* shape_vert_sampling_factor_n */
789                                                    BitstreamSkip(bs, 5);   /* shape_vert_sampling_factor_m */
790                                            }
791                                          return -1;                                          return -1;
792                                  }                                  }
793                          } else                          // dec->shape == BINARY_ONLY                          } else                          // dec->shape == BINARY_ONLY
794                          {                          {
795                                  if (vol_ver_id != 1) {                                  if (vol_ver_id != 1) {
796                                          if (BitstreamGetBit(bs))        // scalability                                          dec->scalability = BitstreamGetBit(bs); /* scalability */
797                                            if (dec->scalability)
798                                          {                                          {
799                                          DPRINTF(DPRINTF_ERROR, "scalability not supported");                                          DPRINTF(DPRINTF_ERROR, "scalability not supported");
800                                                    BitstreamSkip(bs, 4);   /* ref_layer_id */
801                                                    BitstreamSkip(bs, 5);   /* hor_sampling_factor_n */
802                                                    BitstreamSkip(bs, 5);   /* hor_sampling_factor_m */
803                                                    BitstreamSkip(bs, 5);   /* vert_sampling_factor_n */
804                                                    BitstreamSkip(bs, 5);   /* vert_sampling_factor_m */
805                                                  return -1;                                                  return -1;
806                                          }                                          }
807                                  }                                  }
# Line 694  Line 874 
874                                  dec->time_bp = (uint32_t)                                  dec->time_bp = (uint32_t)
875                                          (dec->time_inc_resolution + dec->last_non_b_time - dec->time)%dec->time_inc_resolution;                                          (dec->time_inc_resolution + dec->last_non_b_time - dec->time)%dec->time_inc_resolution;
876                          }                          }
877                            DPRINTF(DPRINTF_HEADER,"time_pp=%i", dec->time_pp);
878                            DPRINTF(DPRINTF_HEADER,"time_bp=%i", dec->time_bp);
879    
880                          READ_MARKER();                          READ_MARKER();
881    
# Line 732  Line 914 
914                                  (coding_type == P_VOP || coding_type == I_VOP)) {                                  (coding_type == P_VOP || coding_type == I_VOP)) {
915    
916                                  *reduced_resolution = BitstreamGetBit(bs);                                  *reduced_resolution = BitstreamGetBit(bs);
917                                    DPRINTF(DPRINTF_HEADER, "reduced_resolution %i", *reduced_resolution);
918                          }                          }
919                          else                          else
920                          {                          {
# Line 767  Line 950 
950                          }                          }
951    
952                          if (dec->shape != VIDOBJLAY_SHAPE_BINARY_ONLY) {                          if (dec->shape != VIDOBJLAY_SHAPE_BINARY_ONLY) {
953    
954                                    if (!dec->complexity_estimation_disable)
955                                    {
956                                            read_vop_complexity_estimation_header(bs, dec, coding_type);
957                                    }
958    
959                                  // intra_dc_vlc_threshold                                  // intra_dc_vlc_threshold
960                                  *intra_dc_threshold =                                  *intra_dc_threshold =
961                                          intra_dc_threshold_table[BitstreamGetBits(bs, 3)];                                          intra_dc_threshold_table[BitstreamGetBits(bs, 3)];
# Line 849  Line 1038 
1038    
1039                  } else if (start_code == USERDATA_START_CODE) {                  } else if (start_code == USERDATA_START_CODE) {
1040                          char tmp[256];                          char tmp[256];
1041                      int i;                      int i, version, build;
1042                            char packed;
1043    
1044                          BitstreamSkip(bs, 32);  // user_data_start_code                          BitstreamSkip(bs, 32);  // user_data_start_code
1045    
# Line 866  Line 1056 
1056    
1057                          DPRINTF(DPRINTF_STARTCODE, "<user_data>: %s\n", tmp);                          DPRINTF(DPRINTF_STARTCODE, "<user_data>: %s\n", tmp);
1058    
1059                          if(strncmp(tmp, "DivX501b481p", 12) == 0) {                      /* divx detection */
1060                                  dec->packed_mode = 1;                          i = sscanf(tmp, "DivX%dBuild%d%c", &version, &build, &packed);
1061                                  DPRINTF(DPRINTF_STARTCODE, "packed_mode = %d\n", dec->packed_mode);                          if (i < 2)
1062                                    i = sscanf(tmp, "DivX%db%d%c", &version, &build, &packed);
1063    
1064                            if (i >= 2)
1065                            {
1066                                    dec->packed_mode = (i == 3 && packed == 'p');
1067                                    DPRINTF(DPRINTF_HEADER, "divx version=%i, build=%i packed=%i",
1068                                                    version, build, dec->packed_mode);
1069                          }                          }
1070    
1071                  } else                                  // start_code == ?                  } else                                  // start_code == ?
1072                  {                  {
1073                          if (BitstreamShowBits(bs, 24) == 0x000001) {                          if (BitstreamShowBits(bs, 24) == 0x000001) {
# Line 917  Line 1114 
1114  {  {
1115          int vol_ver_id=1;          int vol_ver_id=1;
1116    
1117          if ( (pParam->m_quarterpel) || (frame->global_flags & XVID_GMC) )          if ( pParam->m_quarterpel ||  (frame->global_flags & XVID_GMC) ||
1118                     (pParam->global & XVID_GLOBAL_REDUCED))
1119                  vol_ver_id = 2;                  vol_ver_id = 2;
1120    
1121          // video object_start_code & vo_id          // video object_start_code & vo_id
# Line 1029  Line 1227 
1227          if (vol_ver_id != 1)          if (vol_ver_id != 1)
1228          {          {
1229                  BitstreamPutBit(bs, 0);         // newpred_enable                  BitstreamPutBit(bs, 0);         // newpred_enable
1230                  BitstreamPutBit(bs, 0);         // reduced_resolution_vop_enabled  
1231                    BitstreamPutBit(bs, (pParam->global & XVID_GLOBAL_REDUCED)?1:0);
1232                                                                            /* reduced_resolution_vop_enabled */
1233          }          }
1234    
1235          BitstreamPutBit(bs, 0);         // scalability          BitstreamPutBit(bs, 0);         // scalability
# Line 1041  Line 1241 
1241    write vop header    write vop header
1242  */  */
1243  void  void
1244  BitstreamWriteVopHeader(Bitstream * const bs,  BitstreamWriteVopHeader(
1245                                                    Bitstream * const bs,
1246                                                  const MBParam * pParam,                                                  const MBParam * pParam,
1247                                                  const FRAMEINFO * const frame,                                                  const FRAMEINFO * const frame,
1248                                                  int vop_coded)                                                  int vop_coded)
# Line 1080  Line 1281 
1281          if ( (frame->coding_type == P_VOP) || (frame->coding_type == S_VOP) )          if ( (frame->coding_type == P_VOP) || (frame->coding_type == S_VOP) )
1282                  BitstreamPutBits(bs, frame->rounding_type, 1);                  BitstreamPutBits(bs, frame->rounding_type, 1);
1283    
1284            if ((pParam->global & XVID_GLOBAL_REDUCED))
1285                    BitstreamPutBit(bs, (frame->global_flags & XVID_REDUCED)?1:0);
1286    
1287          BitstreamPutBits(bs, 0, 3);     // intra_dc_vlc_threshold          BitstreamPutBits(bs, 0, 3);     // intra_dc_vlc_threshold
1288    
1289          if (frame->global_flags & XVID_INTERLACING) {          if (frame->global_flags & XVID_INTERLACING) {
# Line 1123  Line 1327 
1327                  // no support for brightness_change!                  // no support for brightness_change!
1328          }          }
1329    
1330    
1331            DPRINTF(DPRINTF_HEADER, "quant = %i", frame->quant);
1332    
1333          BitstreamPutBits(bs, frame->quant, 5);  // quantizer          BitstreamPutBits(bs, frame->quant, 5);  // quantizer
1334    
1335          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.10
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4