开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
parse.c
资源名称：dvd-munitions.tar.gz　[点击查看]
上传用户：aoeyumen
上传日期：2007-01-06
资源大小：3329k
文件大小：20k
源码类别：

DVD

开发平台：

Unix_Linux

parse.c：源码内容
  1. /*
  2.  *  parse.c
  3.  *
  4.  *  Copyright (C) Aaron Holtzman <aholtzma@ess.engr.uvic.ca> - Nov 1999
  5.  *
  6.  *  This file is part of mpeg2dec, a free MPEG-2 video stream decoder.
  7.  *
  8.  *  mpeg2dec is free software; you can redistribute it and/or modify
  9.  *  it under the terms of the GNU General Public License as published by
  10.  *  the Free Software Foundation; either version 2, or (at your option)
  11.  *  any later version.
  12.  *   
  13.  *  mpeg2dec is distributed in the hope that it will be useful,
  14.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  *  GNU General Public License for more details.
  17.  *   
  18.  *  You should have received a copy of the GNU General Public License
  19.  *  along with GNU Make; see the file COPYING.  If not, write to
  20.  *  the Free Software Foundation, 
  21.  *
  22.  */
  24. #include <stddef.h>
  25. #include <stdio.h>
  26. #include "config.h"
  27. #include "mpeg2.h"
  28. #include "mpeg2_internal.h"
  30. #include "bitstream.h"
  31. #include "stats.h"
  32. #include "parse.h"
  34. //FIXME remove when new vlc stuff is in
  35. #include "old_crap.h"
  37. //FIXME remove when you put vlc_get_block_coeff into vlc.
  38. typedef struct {
  39.   char run, level, len;
  40. } DCTtab;
  42. extern DCTtab DCTtabfirst[],DCTtabnext[],DCTtab0[],DCTtab1[];
  43. extern DCTtab DCTtab2[],DCTtab3[],DCTtab4[],DCTtab5[],DCTtab6[];
  44. extern DCTtab DCTtab0a[],DCTtab1a[];
  45. //FIXME remove when you put vlc_get_block_coeff into vlc.
  49. uint_32 non_linear_quantizer_scale[32] =
  50. {
  51.    0, 1, 2, 3, 4, 5, 6, 7,
  52.    8,10,12,14,16,18,20,22,
  53.   24,28,32,36,40,44,48,52,
  54.   56,64,72,80,88,96,104,112
  55. };
  57. static uint_8 scan_norm_mmx[64] =
  58. { 
  59. // MMX Zig-Zag scan pattern (transposed)  
  60.  0, 8, 1, 2, 9,16,24,17,10, 3, 4,11,18,25,32,40,
  61. 33,26,19,12, 5, 6,13,20,27,34,41,48,56,49,42,35,
  62. 28,21,14, 7,15,22,29,36,43,50,57,58,51,44,37,30,
  63. 23,31,38,45,52,59,60,53,46,39,47,54,61,62,55,63
  64. };
  66. static uint_8 scan_alt_mmx[64] = 
  67. { 
  68. // Alternate scan pattern (transposed)
  69.  0, 1, 2, 3, 8, 9,16,17,10,11, 4, 5, 6, 7,15,14,
  70. 13,12,19,18,24,25,32,33,26,27,20,21,22,23,28,29,
  71. 30,31,34,35,40,41,48,49,42,43,36,37,38,39,44,45,
  72. 46,47,50,51,56,57,58,59,52,53,54,55,60,61,62,63,
  73. };
  75. static uint_8 scan_norm[64] =
  76. { 
  77. // Zig-Zag scan pattern
  78. 0,1,8,16,9,2,3,10,17,24,32,25,18,11,4,5,
  79. 12,19,26,33,40,48,41,34,27,20,13,6,7,14,21,28,
  80. 35,42,49,56,57,50,43,36,29,22,15,23,30,37,44,51,
  81. 58,59,52,45,38,31,39,46,53,60,61,54,47,55,62,63
  82. };
  84. static uint_8 scan_alt[64] =
  85. { 
  86. // Alternate scan pattern 
  87. 0,8,16,24,1,9,2,10,17,25,32,40,48,56,57,49,
  88. 41,33,26,18,3,11,4,12,19,27,34,42,50,58,35,43,
  89. 51,59,20,28,5,13,6,14,21,29,36,44,52,60,37,45,
  90. 53,61,22,30,7,15,23,31,38,46,54,62,39,47,55,63
  91. };
  93. static uint_8 default_intra_quantization_matrix[64] = 
  94. {
  95.    8, 16, 19, 22, 26, 27, 29, 34,
  96.   16, 16, 22, 24, 27, 29, 34, 37,
  97.   19, 22, 26, 27, 29, 34, 34, 38,
  98.   22, 22, 26, 27, 29, 34, 37, 40,
  99.   22, 26, 27, 29, 32, 35, 40, 48,
  100.   26, 27, 29, 32, 35, 40, 48, 58,
  101.   26, 27, 29, 34, 38, 46, 56, 69,
  102.   27, 29, 35, 38, 46, 56, 69, 83
  103. };
  105. static uint_8 default_non_intra_quantization_matrix[64] = 
  106. {
  107. 16, 16, 16, 16, 16, 16, 16, 16, 
  108. 16, 16, 16, 16, 16, 16, 16, 16, 
  109. 16, 16, 16, 16, 16, 16, 16, 16, 
  110. 16, 16, 16, 16, 16, 16, 16, 16, 
  111. 16, 16, 16, 16, 16, 16, 16, 16, 
  112. 16, 16, 16, 16, 16, 16, 16, 16, 
  113. 16, 16, 16, 16, 16, 16, 16, 16, 
  114. 16, 16, 16, 16, 16, 16, 16, 16 
  115. };
  117. static void parse_sequence_display_extension(picture_t *picture);
  118. static void parse_sequence_extension(picture_t *picture);
  119. static void parse_picture_coding_extension(picture_t *picture);
  121. void
  122. parse_state_init(picture_t *picture)
  123. {
  124. picture->intra_quantizer_matrix = default_intra_quantization_matrix;
  125. picture->non_intra_quantizer_matrix = default_non_intra_quantization_matrix;
  126. //FIXME we should set pointers to the real scan matrices
  127. //here (mmx vs normal) instead of the ifdefs in parse_picture_coding_extension
  128. picture->scan = scan_norm;
  129. }
  131. //FIXME remove once we get everything working
  132. void parse_marker_bit(char *string)
  133. {
  134.   int marker;
  136.   marker = Get_Bits(1);
  138.   if(!marker)
  139.     fprintf(stderr,"(parse) %s marker_bit set to 0n",string);
  140. }
  143. void 
  144. parse_sequence_header(picture_t *picture)
  145. {
  146. uint_32 i;
  148.   picture->horizontal_size             = Get_Bits(12);
  149.   picture->vertical_size               = Get_Bits(12);
  151. //XXX this needs field fixups
  152. picture->coded_picture_height = ((picture->vertical_size + 15)/16) * 16;
  153. picture->coded_picture_width  = ((picture->horizontal_size   + 15)/16) * 16;
  155.   picture->aspect_ratio_information    = Get_Bits(4);
  156.   picture->frame_rate_code             = Get_Bits(4);
  157.   picture->bit_rate_value              = Get_Bits(18);
  158.   parse_marker_bit("sequence_header");
  159.   picture->vbv_buffer_size             = Get_Bits(10);
  160.   picture->constrained_parameters_flag = Get_Bits(1);
  162.   if((picture->use_custom_intra_quantizer_matrix = Get_Bits(1)))
  163.   {
  164. picture->intra_quantizer_matrix = picture->custom_intra_quantization_matrix;
  165.     for (i=0; i < 64; i++)
  166.       picture->custom_intra_quantization_matrix[scan_norm[i]] = Get_Bits(8);
  167.   }
  168. else
  169. picture->intra_quantizer_matrix = default_intra_quantization_matrix;
  171.   if((picture->use_custom_non_intra_quantizer_matrix = Get_Bits(1)))
  172.   {
  173. picture->non_intra_quantizer_matrix = picture->custom_non_intra_quantization_matrix;
  174.     for (i=0; i < 64; i++)
  175.       picture->custom_non_intra_quantization_matrix[scan_norm[i]] = Get_Bits(8);
  176.   }
  177. else
  178. picture->non_intra_quantizer_matrix = default_non_intra_quantization_matrix;
  180. stats_sequence_header(picture);
  182. }
  184. void
  185. parse_extension(picture_t *picture)
  186. {
  187. uint_32 code;
  189. code = Get_Bits(4);
  191. switch(code)
  192. {
  193. case PICTURE_CODING_EXTENSION_ID:
  194. parse_picture_coding_extension(picture);
  195. break;
  197. case SEQUENCE_EXTENSION_ID:
  198. parse_sequence_extension(picture);
  199. break;
  201. case SEQUENCE_DISPLAY_EXTENSION_ID:
  202. parse_sequence_display_extension(picture);
  203. break;
  205. default:
  206. fprintf(stderr,"(parse) unsupported extension %dn",code);
  207. exit(1);
  208. }
  209. }
  211. void
  212. parse_user_data(void)
  213. {
  214.   while (Show_Bits(24)!=0x01L)
  215.     Flush_Buffer(8);
  216. }
  218. static void
  219. parse_sequence_extension(picture_t *picture)
  220. {
  222.   /*picture->profile_and_level_indication = */ Get_Bits(8);
  223.   picture->progressive_sequence           =    Get_Bits(1);
  224.   picture->chroma_format                  =    Get_Bits(2);
  225.   /*picture->horizontal_size_extension    = */ Get_Bits(2);
  226.   /*picture->vertical_size_extension      = */ Get_Bits(2);
  227.   /*picture->bit_rate_extension           = */ Get_Bits(12);
  228.   parse_marker_bit("sequence_extension");
  229.   /*picture->vbv_buffer_size_extension    = */ Get_Bits(8);
  230.   /*picture->low_delay                    = */ Get_Bits(1);
  231.   /*picture->frame_rate_extension_n       = */ Get_Bits(2);
  232.   /*picture->frame_rate_extension_d       = */ Get_Bits(5);
  234. stats_sequence_ext(picture);
  235. //
  236. //XXX since we don't support anything but 4:2:0, die gracefully
  237. if(picture->chroma_format != CHROMA_420)
  238. {
  239. fprintf(stderr,"(parse) sorry, mpeg2dec doesn't support color formats other than 4:2:0n");
  240. exit(1);
  241. }
  242. }
  245. static void
  246. parse_sequence_display_extension(picture_t *picture)
  247. {
  248.   picture->video_format      = Get_Bits(3);
  249.   picture->color_description = Get_Bits(1);
  251.   if (picture->color_description)
  252.   {
  253.     picture->color_primaries          = Get_Bits(8);
  254.     picture->transfer_characteristics = Get_Bits(8);
  255.     picture->matrix_coefficients      = Get_Bits(8);
  256.   }
  258.   picture->display_horizontal_size = Get_Bits(14);
  259.   parse_marker_bit("sequence_display_extension");
  260.   picture->display_vertical_size   = Get_Bits(14);
  262. stats_sequence_display_ext(picture);
  263. }
  265. void 
  266. parse_gop_header(picture_t *picture)
  267. {
  268.   picture->drop_flag   = Get_Bits(1);
  269.   picture->hour        = Get_Bits(5);
  270.   picture->minute      = Get_Bits(6);
  271.   parse_marker_bit("gop_header");
  272.   picture->sec         = Get_Bits(6);
  273.   picture->frame       = Get_Bits(6);
  274.   picture->closed_gop  = Get_Bits(1);
  275.   picture->broken_link = Get_Bits(1);
  277. stats_gop_header(picture);
  279. }
  282. static void 
  283. parse_picture_coding_extension(picture_t *picture)
  284. {
  285.   picture->f_code[0][0] = Get_Bits(4);
  286.   picture->f_code[0][1] = Get_Bits(4);
  287.   picture->f_code[1][0] = Get_Bits(4);
  288.   picture->f_code[1][1] = Get_Bits(4);
  290.   picture->intra_dc_precision         = Get_Bits(2);
  291.   picture->picture_structure          = Get_Bits(2);
  292.   picture->top_field_first            = Get_Bits(1);
  293.   picture->frame_pred_frame_dct       = Get_Bits(1);
  294.   picture->concealment_motion_vectors = Get_Bits(1);
  295.   picture->q_scale_type               = Get_Bits(1);
  296.   picture->intra_vlc_format           = Get_Bits(1);
  297.   picture->alternate_scan             = Get_Bits(1);
  299. #ifdef __i386__
  300. if(picture->alternate_scan)
  301. picture->scan = scan_alt_mmx;
  302. else
  303. picture->scan = scan_norm_mmx;
  304. #else
  305. if(picture->alternate_scan)
  306. picture->scan = scan_alt;
  307. else
  308. picture->scan = scan_norm;
  309. #endif
  311.   picture->repeat_first_field         = Get_Bits(1);
  312. /*chroma_420_type isn't used */       Get_Bits(1);
  313.   picture->progressive_frame          = Get_Bits(1);
  314.   picture->composite_display_flag     = Get_Bits(1);
  316.   if (picture->composite_display_flag)
  317.   {
  318. //This info is not used in the decoding process
  319.     /* picture->v_axis            = */ Get_Bits(1);
  320.     /* picture->field_sequence    = */ Get_Bits(3);
  321.     /* picture->sub_carrier       = */ Get_Bits(1);
  322.     /* picture->burst_amplitude   = */ Get_Bits(7);
  323.     /* picture->sub_carrier_phase = */ Get_Bits(8);
  324.   }
  326. //XXX die gracefully if we encounter a field picture based stream
  327. if(picture->picture_structure != FRAME_PICTURE)
  328. {
  329. fprintf(stderr,"(parse) sorry, mpeg2dec doesn't support field based pictures yetn");
  330. exit(1);
  331. }
  333. stats_picture_coding_ext_header(picture);
  334. }
  336. void 
  337. parse_picture_header(picture_t *picture)
  338. {
  339.   picture->temporal_reference  = Get_Bits(10);
  340.   picture->picture_coding_type = Get_Bits(3);
  341.   picture->vbv_delay           = Get_Bits(16);
  343.   if (picture->picture_coding_type==P_TYPE || picture->picture_coding_type==B_TYPE)
  344.   {
  345.     picture->full_pel_forward_vector = Get_Bits(1);
  346.     picture->forward_f_code = Get_Bits(3);
  347.   }
  348.   if (picture->picture_coding_type==B_TYPE)
  349.   {
  350.     picture->full_pel_backward_vector = Get_Bits(1);
  351.     picture->backward_f_code = Get_Bits(3);
  352.   }
  354. stats_picture_header(picture);
  355. }
  358. void
  359. parse_slice_header(const picture_t *picture, slice_t *slice)
  360. {
  362. uint_32 intra_slice_flag;
  364.   slice->quantizer_scale_code = Get_Bits(5);
  366. if (picture->q_scale_type)
  367.    slice->quantizer_scale = non_linear_quantizer_scale[slice->quantizer_scale_code];
  368. else
  369.    slice->quantizer_scale = slice->quantizer_scale_code << 1 ;
  372.   if ((intra_slice_flag = Get_Bits(1)))
  373.   {
  374. //Ignore the value of intra_slice
  375.     Get_Bits(1);
  377.     slice->slice_picture_id_enable = Get_Bits(1);
  378. slice->slice_picture_id = Get_Bits(6);
  380. //Ignore all the extra_data
  381. while(Get_Bits1())
  382. Flush_Buffer(8);
  383. }
  385. //reset intra dc predictor
  386. slice->dc_dct_pred[0]=slice->dc_dct_pred[1]=slice->dc_dct_pred[2]= 
  387. 1<<(picture->intra_dc_precision + 7) ;
  389. stats_slice_header(slice);
  390. }
  393. //This goes into vlc.c when it gets written
  394. sint_32
  395. vlc_get_block_coeff(uint_16 non_intra_dc,uint_16 intra_vlc_format)
  396. {
  397.   uint_32 code;
  398.   DCTtab *tab;
  399. uint_16 run;
  400. sint_16 val;
  402. //this routines handles intra AC and non-intra AC/DC coefficients
  403. code = Show_Bits(16);
  404.  
  405. if (code>=16384 && !intra_vlc_format)
  406. {
  407. if (non_intra_dc)
  408. tab = &DCTtabfirst[(code>>12)-4];
  409. else
  410. tab = &DCTtabnext[(code>>12)-4];
  411. }
  412. else if (code>=1024)
  413. {
  414. if (intra_vlc_format)
  415. tab = &DCTtab0a[(code>>8)-4];
  416. else
  417. tab = &DCTtab0[(code>>8)-4];
  418. }
  419. else if (code>=512)
  420. {
  421. if (intra_vlc_format)
  422. tab = &DCTtab1a[(code>>6)-8];
  423. else
  424. tab = &DCTtab1[(code>>6)-8];
  425. }
  426. else if (code>=256)
  427. tab = &DCTtab2[(code>>4)-16];
  428. else if (code>=128)
  429. tab = &DCTtab3[(code>>3)-16];
  430. else if (code>=64)
  431. tab = &DCTtab4[(code>>2)-16];
  432. else if (code>=32)
  433. tab = &DCTtab5[(code>>1)-16];
  434. else if (code>=16)
  435. tab = &DCTtab6[code-16];
  436. else
  437. {
  438. fprintf(stderr,"invalid Huffman code in vlc_get_block_coeff()n");
  439. return 0;
  440. }
  442. Flush_Buffer(tab->len);
  444. if (tab->run==64) // end_of_block 
  445. return 0;
  447. if (tab->run==65) /* escape */
  448. {
  449. run = Get_Bits(6);
  451. val = Get_Bits(12);
  453. if ((val&2047)==0)
  454. {
  455. fprintf(stderr,"invalid escape in vlc_get_block_coeff()n");
  456. return 0;
  457. }
  459. if(val >= 2048)
  460. val =  val - 4096;
  461. }
  462. else
  463. {
  464. run = tab->run;
  465. val = tab->level;
  466.  
  467. if(Get_Bits(1)) //sign bit
  468. val = -val;
  469. }
  471. return ((val << 16) + run);
  472. }
  475. void
  476. parse_intra_block(const picture_t *picture,slice_t *slice,sint_16 *dest,uint_32 cc)
  477. {
  478. sint_32 coeff;
  479. uint_32 i = 1;
  480. uint_32 j;
  481. uint_16 run;
  482. sint_16 val;
  483. uint_8 *scan = picture->scan;
  484. uint_8 *quant_matrix = picture->intra_quantizer_matrix;
  485. sint_16 quantizer_scale = slice->quantizer_scale;
  487. //Clear the entire block and bring it into the cache
  488. //XXX we should perhaps do this at the start of the frame
  489. memset(dest,0,sizeof(sint_16) * 64);
  491. //Get the intra DC coefficient and inverse quantize it
  492.   if (cc == 0)
  493.     dest[0] = (slice->dc_dct_pred[0] += Get_Luma_DC_dct_diff()) << (3 - picture->intra_dc_precision);
  494.   else 
  495.     dest[0] = (slice->dc_dct_pred[cc]+= Get_Chroma_DC_dct_diff()) << (3 - picture->intra_dc_precision);
  497. //FIXME convert the cross platform IDCT to use 11.4 fixed point
  498. #ifdef __i386__
  499. dest[0] <<= 4;
  500. #endif
  502. i = 1;
  503. while((coeff = vlc_get_block_coeff(0,picture->intra_vlc_format)))
  504. {
  505. val = coeff >> 16;
  506. run = coeff & 0xffffL;
  508. i += run;
  509.     j = scan[i++];
  511. //FIXME convert the cross platform IDCT to use 11.4 fixed point
  512. #ifdef __i386__
  513.     dest[j] = (val * quantizer_scale * quant_matrix[j]);
  514. #else
  515.     dest[j] = (val * quantizer_scale * quant_matrix[j]) >> 4;
  516. #endif
  518. #if 0
  519. sint_32 sum = 0;
  520. if(dest[j] > 2047)
  521. dest[j] = 2047;
  522. else if(dest[j] < -2048)
  523. dest[j] = -2048;
  525. sum += dest[j];
  526. #endif
  527. }
  529. #if 0
  530. if ((sum & 1) == 0)
  531. dest[63] ^= 1;
  532. #endif
  534. if(i > 64)
  535. {
  536. fprintf(stderr,"Invalid DCT index in parse_intra_block()n");
  537. exit(1);
  538. }
  539. }
  541. void
  542. parse_non_intra_block(const picture_t *picture,slice_t *slice,sint_16 *dest,uint_32 cc)
  543. {
  544. uint_32 coeff;
  545. uint_32 i = 0;
  546. uint_32 j;
  547. uint_16 run;
  548. sint_16 val;
  549. uint_8 *scan = picture->scan;
  550. uint_8 *quant_matrix = picture->intra_quantizer_matrix;
  551. sint_16 quantizer_scale = slice->quantizer_scale;
  553. //Clear the entire block and bring it into the cache
  554. memset(dest,0,sizeof(sint_16) * 64);
  556. while((coeff = vlc_get_block_coeff(i==0,0)))
  557. {
  558. val = coeff >> 16;
  559. run = coeff & 0xffffL;
  561. i += run;
  562.     j = scan[i++];
  563. //FIXME mmx
  564. //FIXME convert the cross platform IDCT to use 11.4 fixed point
  565. #ifdef __i386__
  566.     dest[j] = (((val<<1) + (val>>15))* quantizer_scale * quant_matrix[j]) >> 1;
  567. #else
  568.     dest[j] = (((val<<1) + (val>>15))* quantizer_scale * quant_matrix[j]) >> 5;
  569. #endif
  570. }
  572. if(i > 64)
  573. {
  574. fprintf(stderr,"Invalid DCT index in parse_intra_block()n");
  575. exit(1);
  576. }
  577. }
  580. void
  581. parse_macroblock(const picture_t *picture,slice_t* slice, macroblock_t *mb)
  582. {
  583.   uint_32 quantizer_scale_code;
  584.   uint_32 picture_structure = picture->picture_structure;
  585. uint_32 i;
  587. //Clear the skipped flag
  588. mb->skipped = 0;
  590.   // get macroblock_type 
  591.   mb->macroblock_type = Get_macroblock_type(picture->picture_coding_type);
  593.   // get frame/field motion type 
  594.   if (mb->macroblock_type & (MACROBLOCK_MOTION_FORWARD|MACROBLOCK_MOTION_BACKWARD))
  595.   {
  596.     if (picture_structure==FRAME_PICTURE) // frame_motion_type 
  597.     {
  598.       mb->motion_type = picture->frame_pred_frame_dct ? MC_FRAME : Get_Bits(2);
  599. if(!picture->frame_pred_frame_dct)
  600.       {
  601.         printf("frame_motion_type (");
  602.         printf("): %sn",mb->motion_type==MC_FIELD?"Field":
  603.                          mb->motion_type==MC_FRAME?"Frame":
  604.                          mb->motion_type==MC_DMV?"Dual_Prime":"Invalid");
  605. }
  606.       
  607.     }
  608.     else // field_motion_type 
  609.     {
  610.       mb->motion_type = Get_Bits(2);
  611.     }
  612.   }
  613.   else if ((mb->macroblock_type & MACROBLOCK_INTRA) && picture->concealment_motion_vectors)
  614.   {
  615.     // concealment motion vectors 
  616.     mb->motion_type = (picture_structure==FRAME_PICTURE) ? MC_FRAME : MC_FIELD;
  617.   }
  619.   // derive motion_vector_count, mv_format and dmv, (table 6-17, 6-18)
  620.   if (picture_structure==FRAME_PICTURE)
  621.   {
  622.     //mb->motion_vector_count = (motion_type==MC_FIELD && stwclass<2) ? 2 : 1;
  623.     mb->motion_vector_count = 1;
  624.     mb->mv_format = (mb->motion_type==MC_FRAME) ? MV_FRAME : MV_FIELD;
  625.   }
  626.   else
  627.   {
  628.     mb->motion_vector_count = (mb->motion_type==MC_16X8) ? 2 : 1;
  629.     mb->mv_format = MV_FIELD;
  630.   }
  632.   mb->dmv = (mb->motion_type==MC_DMV); // dual prime
  634. //Set if we need to scale motion vector prediction by 1/2
  635.   mb->mvscale = ((mb->mv_format==MV_FIELD) && (picture_structure==FRAME_PICTURE));
  637.   // get dct_type (frame DCT / field DCT) 
  638. if( (picture_structure==FRAME_PICTURE) && (!picture->frame_pred_frame_dct) && 
  639. (mb->macroblock_type & (MACROBLOCK_PATTERN|MACROBLOCK_INTRA)) )
  640. mb->dct_type =  Get_Bits(1);
  641. else
  642. mb->dct_type =  0;
  645. if (mb->macroblock_type & MACROBLOCK_QUANT)
  646.   {
  647.     quantizer_scale_code = Get_Bits(5);
  649. //The quantizer scale code propogates up to the slice level
  650. if(picture->q_scale_type)
  651. slice->quantizer_scale = non_linear_quantizer_scale[quantizer_scale_code];
  652. else
  653.       slice->quantizer_scale = quantizer_scale_code << 1;
  654.   }
  657.   // 6.3.17.2 Motion vectors 
  659.   // decode forward motion vectors 
  660.   if ((mb->macroblock_type & MACROBLOCK_MOTION_FORWARD) || 
  661. ((mb->macroblock_type & MACROBLOCK_INTRA) && picture->concealment_motion_vectors))
  662.   {
  663. //Field pictures are definately broken here
  664. //FIXME this could be faster too
  665.       motion_vectors(slice->pmv,(int*)mb->dmvector,mb->motion_vertical_field_select,
  666.         0,mb->motion_vector_count,mb->mv_format,0,0,mb->dmv,
  667. mb->mvscale);
  668.   }
  670.   // decode backward motion vectors 
  671.   if (mb->macroblock_type & MACROBLOCK_MOTION_BACKWARD)
  672.   {
  673.       motion_vectors(slice->pmv,(int*)mb->dmvector,mb->motion_vertical_field_select,
  674.         1,mb->motion_vector_count,mb->mv_format,0,0,mb->dmv,
  675.         mb->mvscale);
  676.   }
  678.   if ((mb->macroblock_type & MACROBLOCK_INTRA) && picture->concealment_motion_vectors)
  679.     Flush_Buffer(1); // remove marker_bit 
  681.   // 6.3.17.4 Coded block pattern 
  682.   if (mb->macroblock_type & MACROBLOCK_PATTERN)
  683.   {
  684.     mb->coded_block_pattern = Get_coded_block_pattern();
  686.     if (picture->chroma_format==CHROMA_422)
  687.     {
  688.       // coded_block_pattern_1 
  689.       mb->coded_block_pattern = (mb->coded_block_pattern<<2) | Get_Bits(2); 
  691. }
  692. else if (picture->chroma_format==CHROMA_444)
  693. {
  694. // coded_block_pattern_2 
  695. mb->coded_block_pattern = (mb->coded_block_pattern<<6) | Get_Bits(6); 
  696. }
  697. }
  698.   else
  699.     mb->coded_block_pattern = (mb->macroblock_type & MACROBLOCK_INTRA) ? 
  700.       0x3f : 0;
  702. //FIXME remove
  703. //fprintf(stderr,"(mb) cbp %02xn",mb->coded_block_pattern);
  705. //coded_block_pattern is set only if there are blocks in bitstream
  706.   if(mb->coded_block_pattern)
  707. {
  708. //XXX only 4:2:0 is supported here - fix later
  710. // Decode lum blocks 
  711. for (i=0; i<4; i++)
  712. {
  713. if (mb->coded_block_pattern & (1<<(5-i)))
  714. {
  715. if (mb->macroblock_type & MACROBLOCK_INTRA)
  716. parse_intra_block(picture,slice,&mb->y_blocks[i*64],0);
  717. else
  718. parse_non_intra_block(picture,slice,&mb->y_blocks[i*64],0);
  719. }
  720. }
  722. // Decode chroma blocks 
  723. if (mb->coded_block_pattern & 0x2)
  724. {
  725. if (mb->macroblock_type & MACROBLOCK_INTRA)
  726. parse_intra_block(picture,slice,mb->cr_blocks,1);
  727. else
  728. parse_non_intra_block(picture,slice,mb->cr_blocks,1);
  729. }
  731. if (mb->coded_block_pattern & 0x1)
  732. {
  733. if (mb->macroblock_type & MACROBLOCK_INTRA)
  734. parse_intra_block(picture,slice,mb->cb_blocks,2);
  735. else
  736. parse_non_intra_block(picture,slice,mb->cb_blocks,2);
  737. }
  738. }
  740.   // 7.2.1 DC coefficients in intra blocks 
  741.   if (!(mb->macroblock_type & MACROBLOCK_INTRA))
  742. {
  743. //FIXME this looks suspicious...should be reset to 2^(intra_dc_precision+7)
  744. //
  745. //lets see if it works
  746. slice->dc_dct_pred[0]=slice->dc_dct_pred[1]=slice->dc_dct_pred[2]= 
  747. 1<<(picture->intra_dc_precision + 7) ;
  748. }
  750.   //7.6.3.4 Resetting motion vector predictors 
  751.   if ((mb->macroblock_type & MACROBLOCK_INTRA) && !picture->concealment_motion_vectors)
  752. memset(slice->pmv,0,sizeof(uint_16) * 8);
  755.   // special "No_MC" macroblock_type case 
  756.   // 7.6.3.5 Prediction in P pictures 
  757.   if ((picture->picture_coding_type==P_TYPE) 
  758.     && !(mb->macroblock_type & (MACROBLOCK_MOTION_FORWARD|MACROBLOCK_INTRA)))
  759.   {
  760.     // non-intra mb without forward mv in a P picture 
  761.     // 7.6.3.4 Resetting motion vector predictors 
  762. memset(slice->pmv,0,sizeof(uint_16) * 8);
  764.     //6.3.17.1 Macroblock modes, frame_motion_type 
  765.     //if (picture_structure==FRAME_PICTURE)
  766.     //  *motion_type = MC_FRAME;
  767.     //else
  768.     //{
  769.     //  *motion_type = MC_FIELD;
  770.     //  /* predict from field of same parity */
  771.     //  motion_vertical_field_select[0][0] = (picture_structure==BOTTOM_FIELD);
  772.     //}
  773.   }
  775.   //if (*stwclass==4)
  776.   //{
  777.   //  /* purely spatially predicted macroblock */
  778.   //  /* 7.7.5.1 Resetting motion vector predictions */
  779. //  slice_reset_pmv(slice);
  780.   // }
  781. }