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

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

DVD

开发平台：

Unix_Linux

getpic.cc：源码内容
  1. /*
  2.   File: getpic.cc
  4. */
  6. #include <string.h>
  7. #include "all.hh"
  9. #ifdef HAVE_MMX
  10. extern "C" void IDCT_mmx(short *);
  11. extern "C" void add_block_mmx(unsigned char *, short *, int);
  12. extern "C" void set_block_mmx(unsigned char *, short *, int);
  13. static unsigned long long MMX_128 = 0x80008000800080LL;
  15. #endif
  17. /* ---------------------------------------------------
  18. */
  19. static void j_rev_dct_sparse (short *data)
  20. {
  21.   short int val;
  22.   int v;
  23.   int quant;
  24.   v = *data;
  25. #ifdef HAVE_MMX
  26.   quant = 8 * 16;
  27. #else
  28.   quant = 8;
  29. #endif
  30.   if (v < 0) {
  31.     val = -v;
  32.     val += (quant >> 1);
  33.     val /= quant;
  34.     val = -val;
  35.   }
  36.   else {
  37.     val = (v + (quant >> 1)) / quant;
  38.   }
  39.   *data = val;
  40.   return;
  41. }
  44. // decode one frame or field picture
  46. void LayerData::getpicture(int framenum){
  47.   if (pict_struct==FRAME_PICTURE && secondfield){
  48.     /* recover from illegal number of field pictures */
  49.     printf("odd number of field picturesn");
  50.     secondfield = 0;
  51.   }
  53.   for (int i=0; i<3; i++){
  54.     if (pict_type==B_TYPE) newframe[i] = auxframe[i];
  55.     else {
  56.       if (!secondfield){
  57.         unsigned char* tmp = oldrefframe[i];
  58.         oldrefframe[i] = refframe[i];
  59.         refframe[i] = tmp;
  60.       }
  62.       newframe[i] = refframe[i];
  63.     }
  65.     if (pict_struct==BOTTOM_FIELD)
  66.       newframe[i]+= (i==0) ? coded_picture_width : chrom_width;
  67.   }
  69. //if (pict_scal && !secondfield) getspatref();
  71.   getMBs(framenum);
  73.   if (framenum!=0){
  74.     if (pict_struct==FRAME_PICTURE || secondfield){
  75.       if (pict_type==B_TYPE) display->dither(auxframe);
  76.       else                   display->dither(oldrefframe);
  77.     }
  78.     else display->display_second_field();
  79.   }
  81.   if (pict_struct!=FRAME_PICTURE) secondfield = !secondfield;
  82. }
  85. // store last frame
  87. void LayerData::putlast(){
  88.   if (secondfield) printf("last frame incomplete, not storedn");
  89.   else display->dither(refframe);
  90. }
  93. /* decode all macroblocks of the current picture */
  95. void LayerData::getMBs(int framenum){
  96.   int comp;
  97.   int MBA, MBAmax, MBAinc, mb_type, cbp, motion_type(0), dct_type;
  98.   int slice_vert_pos_ext;
  99.   int bx, by;
  100.   unsigned int code;
  101.   int dc_dct_pred[3];
  102.   int mv_count, mv_format, mvscale;
  103.   int PMV[2][2][2], mv_field_sel[2][2];
  104.   int dmv, dmvector[2];
  105.   int qs;
  106.   int stwtype, stwclass; 
  107.   int SNRcbp;
  108. //  int SNRMBA(0), SNRmb_type,, SNRMBAinc(0), SNRdct_type, dummy; // SNR scal.
  110.   /* number of macroblocks per picture */
  111.   MBAmax = mb_width*mb_height;
  113.   if (pict_struct!=FRAME_PICTURE)
  114.     MBAmax>>=1; /* field picture has half as mnay macroblocks as frame */
  116.   MBA = 0; /* macroblock address */
  117.   MBAinc = 0;
  119. /*
  120.   if (twostreams && enhan.scalable_mode==SC_SNR){
  121.     SNRMBA=0;
  122.     SNRMBAinc=0;
  123.   }
  124. */
  126.   fault=0;
  128.   for (;;){
  129. #ifdef TRACE
  130.     if (trace) printf("frame %d, MB %dn",framenum,MBA);
  131. #endif
  133.     if (!prog_seq && pict_struct==FRAME_PICTURE && MBA==(MBAmax>>1) &&
  134.         framenum!=0)
  135. // && display->getType()==T_X11)
  136.       display->display_second_field();
  138. //  ld = &base;
  139.     if (MBAinc==0){
  140. //      if (scalable_mode==SC_DP && pri_brk==1) ld = &enhan;
  142.       if (!input->showbits(23) || fault){ /* startcode or fault */
  143. resync: /* if fault: resynchronize to next startcode */
  144.         fault = 0;
  146.         if (MBA>=MBAmax) return; /* all macroblocks decoded */
  148.         code=input->startcode();
  149.         if (code<Slice_min_start || code>Slice_max_start){
  150.           /* only slice headers are allowed in picture_data */
  151.           if (!quiet) printf("Premature end of picturen");
  152.           return;
  153.         }
  154.         input->flushbits(32);
  156.         /* decode slice header (may change quant_scale) */
  157.         slice_vert_pos_ext = getslicehdr();
  159. /*
  160.         if (scalable_mode==SC_DP){
  161.           ld = &enhan;
  162.           input->startcode();
  163.           code = input->showbits(32);
  165.           if (code<SLICE_MIN_START || code>SLICE_MAX_START){
  166.             // only slice headers are allowed in picture_data
  167.             if (!quiet) printf("Premature end of picturen");
  168.             return;
  169.           }
  171.           input->flushbits(32);
  173.           // decode slice header (may change quant_scale)
  174.           slice_vert_pos_ext = getslicehdr();
  176. //          if (pri_brk!=1) ld = &base;
  177.         }
  178. */
  180.         /* decode macroblock address increment */
  181.         MBAinc = getMBA();
  183.         if (fault) goto resync;
  185.         /* set current location */
  186.         MBA = ((slice_vert_pos_ext<<7) + (code&255) - 1)*mb_width + MBAinc - 1;
  187.         MBAinc = 1; /* first macroblock in slice: not skipped */
  189.         /* reset all DC coefficient and motion vector predictors */
  190.         dc_dct_pred[0]=dc_dct_pred[1]=dc_dct_pred[2]=0;
  191.         PMV[0][0][0]=PMV[0][0][1]=PMV[1][0][0]=PMV[1][0][1]=0;
  192.         PMV[0][1][0]=PMV[0][1][1]=PMV[1][1][0]=PMV[1][1][1]=0;
  193.       }
  194.       else { /* neither startcode nor fault */
  195.         if (MBA>=MBAmax){
  196.           if (!quiet) printf("Too many macroblocks in picturen");
  197.           return;
  198.         }
  200. /*
  201.         if (scalable_mode==SC_DP && pri_brk==1) ld = &enhan;
  202. */
  203.         /* decode macroblock address increment */
  204.         MBAinc = getMBA();
  206.         if (fault) goto resync;
  207.       }
  208.     }
  210.     if (MBA>=MBAmax){
  211.       /* MBAinc points beyond picture dimensions */
  212.       if (!quiet) printf("Too many macroblocks in picturen");
  213.       return;
  214.     }
  216.     if (MBAinc==1) /* not skipped */{
  217. /*
  218.       if (scalable_mode==SC_DP){
  219.         if (pri_brk<=2) ld = &enhan;
  220.         else ld = &base;
  221.       }
  222. */
  224.       macroblock_modes(&mb_type, &stwtype, &stwclass,
  225.         &motion_type, &mv_count, &mv_format, &dmv, &mvscale, &dct_type);
  227.       if (fault) goto resync;
  229.       if (mb_type & MB_QUANT){
  230.         qs = input->getbits(5);
  232. #ifdef TRACE
  233.         if (trace){
  234.           printf("quantiser_scale_code (");
  235.           printbits(qs,5,5);
  236.           printf("): %dn",qs);
  237.         }
  238. #endif
  240.         if (mpeg2)
  241.              quant_scale = qscale_type ? non_linear_mquant_table[qs] : (qs << 1);
  242.         else quant_scale = qs;
  244.         if (scalable_mode==SC_DP)
  245.           /* make sure quant_scale is valid */
  246.           quant_scale = quant_scale;
  247.       }
  249.       /* motion vectors */
  251.       /* decode forward motion vectors */
  252.       if ((mb_type & MB_FORWARD) || ((mb_type & MB_INTRA) && conceal_mv)){
  253.         if (mpeg2)
  254.           motion_vectors(PMV,dmvector,mv_field_sel,
  255.             0,mv_count,mv_format,h_forw_r_size,v_forw_r_size,dmv,mvscale);
  256.         else
  257.           motion_vector(PMV[0][0],dmvector,
  258.             forw_r_size,forw_r_size,0,0,full_forw);
  259.       }
  261.       if (fault) goto resync;
  263.       /* decode backward motion vectors */
  264.       if (mb_type & MB_BACKWARD){
  265.         if (mpeg2)
  266.           motion_vectors(PMV,dmvector,mv_field_sel,
  267.             1,mv_count,mv_format,h_back_r_size,v_back_r_size,0,mvscale);
  268.         else
  269.           motion_vector(PMV[0][1],dmvector,
  270.             back_r_size,back_r_size,0,0,full_back);
  271.       }
  273.       if (fault) goto resync;
  275.       if ((mb_type & MB_INTRA) && conceal_mv)
  276.         input->flushbits(1); /* remove marker_bit */
  278. /*
  279.       if (scalable_mode==SC_DP && pri_brk==3) ld = &enhan;
  280. */
  282.       /* macroblock_pattern */
  283.       if (mb_type & MB_PATTERN){
  284.         cbp = getCBP();
  285.         if (chroma_format==CHROMA422){
  286.           cbp = (cbp<<2) | input->getbits(2); /* coded_block_pattern_1 */
  288. #ifdef TRACE
  289.           if (trace){
  290.             printf("coded_block_pattern_1: ");
  291.             printbits(cbp,2,2);
  292.             printf(" (%d)n",cbp&3);
  293.           }
  294. #endif
  295.         }
  296.         else if (chroma_format==CHROMA444){
  297.           cbp = (cbp<<6) | input->getbits(6); /* coded_block_pattern_2 */
  299. #ifdef TRACE
  300.           if (trace){
  301.             printf("coded_block_pattern_2: ");
  302.             printbits(cbp,6,6);
  303.             printf(" (%d)n",cbp&63);
  304.           }
  305. #endif
  306.         }
  307.       }
  308.       else
  309.         cbp = (mb_type & MB_INTRA) ? (1<<blk_cnt)-1 : 0;
  311.       if (fault) goto resync;
  313.       /* decode blocks */
  314.       clearblock(0,blk_cnt);
  315.       for (comp=0; comp<blk_cnt; comp++){
  316. //        if (scalable_mode==SC_DP) ld = &base;
  319.         if (cbp & (1<<(blk_cnt-1-comp))){
  320.           if (mb_type & MB_INTRA){
  321.             if (mpeg2) getmpg2intrablock(comp,dc_dct_pred);
  322.             else           getintrablock(comp,dc_dct_pred);
  323.           }
  324.           else {
  325.             if (mpeg2) getmpg2interblock(comp);
  326.             else           getinterblock(comp);
  327.           }
  329.           if (fault) goto resync;
  330.         }
  331.       }
  333.       /* reset intra_dc predictors */
  334.       if (!(mb_type & MB_INTRA))
  335.         dc_dct_pred[0]=dc_dct_pred[1]=dc_dct_pred[2]=0;
  337.       /* reset motion vector predictors */
  338.       if ((mb_type & MB_INTRA) && !conceal_mv){
  339.         /* intra mb without concealment motion vectors */
  340.         PMV[0][0][0]=PMV[0][0][1]=PMV[1][0][0]=PMV[1][0][1]=0;
  341.         PMV[0][1][0]=PMV[0][1][1]=PMV[1][1][0]=PMV[1][1][1]=0;
  342.       }
  344.       if ((pict_type==P_TYPE) && !(mb_type & (MB_FORWARD|MB_INTRA))){
  345.         /* non-intra mb without forward mv in a P picture */
  346.         PMV[0][0][0]=PMV[0][0][1]=PMV[1][0][0]=PMV[1][0][1]=0;
  348.         /* derive motion_type */
  349.         if (pict_struct==FRAME_PICTURE) motion_type = MC_FRAME;
  350.         else
  351.         {
  352.           motion_type = MC_FIELD;
  353.           /* predict from field of same parity */
  354.           mv_field_sel[0][0] = (pict_struct==BOTTOM_FIELD);
  355.         }
  356.       }
  358.       if (stwclass==4)
  359.       {
  360.         /* purely spatially predicted macroblock */
  361.         PMV[0][0][0]=PMV[0][0][1]=PMV[1][0][0]=PMV[1][0][1]=0;
  362.         PMV[0][1][0]=PMV[0][1][1]=PMV[1][1][0]=PMV[1][1][1]=0;
  363.       }
  364.     }
  365.     else { /* MBAinc!=1: skipped macroblock */
  366. //      if (scalable_mode==SC_DP) ld = &base;
  368.       clearblock(0,blk_cnt);
  370.       /* reset intra_dc predictors */
  371.       dc_dct_pred[0]=dc_dct_pred[1]=dc_dct_pred[2]=0;
  373.       /* reset motion vector predictors */
  374.       if (pict_type==P_TYPE)
  375.         PMV[0][0][0]=PMV[0][0][1]=PMV[1][0][0]=PMV[1][0][1]=0;
  377.       /* derive motion_type */
  378.       if (pict_struct==FRAME_PICTURE)
  379.         motion_type = MC_FRAME;
  380.       else
  381.       {
  382.         motion_type = MC_FIELD;
  383.         /* predict from field of same parity */
  384.         mv_field_sel[0][0]=mv_field_sel[0][1] = (pict_struct==BOTTOM_FIELD);
  385.       }
  387.       /* skipped I are spatial-only predicted, */
  388.       /* skipped P and B are temporal-only predicted */
  389.       stwtype = (pict_type==I_TYPE) ? 8 : 0;
  391.       /* clear MB_INTRA */
  392.       mb_type&= ~MB_INTRA;
  394.       cbp = 0; /* no block data */
  395.     }
  397.     SNRcbp = 0;
  399. #ifdef ENHANCEMENT
  401.     if (twostreams && enhan.scalable_mode==SC_SNR){
  402.       ld = &enhan;
  403.       if (SNRMBAinc==0){
  404.         if (!input->showbits(23)){ /* startcode */
  405.           code=input->startcode();
  406. //          code = input->showbits(32);
  407.           if (code<SLICE_MIN_START || code>SLICE_MAX_START){
  408.             /* only slice headers are allowed in picture_data */
  409.             if (!quiet)
  410.               printf("Premature end of picturen");
  411.             return;
  412.           }
  413.           input->flushbits(32);
  415.           /* decode slice header (may change quant_scale) */
  416.           slice_vert_pos_ext = getslicehdr();
  418.           /* decode macroblock address increment */
  419.           SNRMBAinc = getMBA();
  421.           /* set current location */
  422.           SNRMBA =
  423.             ((slice_vert_pos_ext<<7) + (code&255) - 1)*mb_width + SNRMBAinc - 1;
  425.           SNRMBAinc = 1; /* first macroblock in slice: not skipped */
  426.         }
  427.         else { /* not startcode */
  428.           if (SNRMBA>=MBAmax){
  429.             if (!quiet) printf("Too many macroblocks in picturen");
  430.             return;
  431.           }
  433.           /* decode macroblock address increment */
  434.           SNRMBAinc = getMBA();
  435.         }
  436.       }
  438.       if (SNRMBA!=MBA){
  439.         /* streams out of sync */
  440.         if (!quiet) printf("Cant't synchronize streamsn");
  441.         return;
  442.       }
  444.       if (SNRMBAinc==1){     /* not skipped */
  445.         macroblock_modes(&SNRmb_type, &dummy, &dummy,
  446.           &dummy, &dummy, &dummy, &dummy, &dummy,
  447.           &SNRdct_type);
  449.         if (SNRmb_type & MB_PATTERN) dct_type = SNRdct_type;
  451.         if (SNRmb_type & MB_QUANT){
  452.           qs = input->getbits(5);
  453.           quant_scale = qscale_type ? non_linear_mquant_table[qs] : qs<<1;
  454.         }
  456.         /* macroblock_pattern */
  457.         if (SNRmb_type & MB_PATTERN)
  458.         {
  459.           SNRcbp = getCBP();
  461.           if (chroma_format==CHROMA422)
  462.             SNRcbp = (SNRcbp<<2) | input->getbits(2); /* coded_block_pattern_1 */
  463.           else if (chroma_format==CHROMA444)
  464.             SNRcbp = (SNRcbp<<6) | input->getbits(6); /* coded_block_pattern_2 */
  465.         }
  466.         else
  467.           SNRcbp = 0;
  469.         /* decode blocks */
  470.         clearblock(0,blk_cnt);
  471.         for (comp=0; comp<blk_cnt; comp++)
  472.         {
  474.           if (SNRcbp & (1<<(blk_cnt-1-comp)))
  475.             getmpg2interblock(comp);
  476.         }
  477.       }
  478.       else /* SNRMBAinc!=1: skipped macroblock */
  479.       {
  480.         clearblock(0,blk_cnt);
  481.       }
  483. //      ld = &base;
  484.     }
  485. #endif
  487.     /* pixel coordinates of top left corner of current macroblock */
  488.     bx = 16*(MBA%mb_width);
  489.     by = 16*(MBA/mb_width);
  491.     /* motion compensation */
  492.     if (!(mb_type & MB_INTRA))
  493.       reconstruct(bx,by,mb_type,motion_type,PMV,mv_field_sel,dmvector,
  494.                   stwtype);
  496. #ifdef ENHANCEMENT
  497.     if (scalable_mode==SC_DP) ld = &base;
  498. #endif
  500.     /* copy or add block data into picture */
  501.     for (comp=0; comp<blk_cnt; comp++){
  502.       if ((cbp|SNRcbp) & (1<<(blk_cnt-1-comp))){
  503. #ifdef ENHANCEMENT
  504.         if (twostreams && enhan.scalable_mode==SC_SNR &&
  505.             SNRcbp & (1<<(blk_cnt-1-comp)))
  506.           sumblock(comp); /* add SNR enhancement layer data to base layer */
  507. #endif
  508.         /* inverse DCT */
  509. //        if (sparse[comp])
  510. //           j_rev_dct_sparse(block[comp]);
  511. //        else {
  512. #ifdef HAVE_MMX
  513.      IDCT_mmx(block[comp]);
  514. #else
  515.           idct->conversion(block[comp]);
  516. #endif
  517. //        }
  518.         addblock(comp,bx,by,dct_type,(mb_type & MB_INTRA)==0);
  519.       }
  520.     }
  522.     /* advance to next macroblock */
  523.     MBA++;
  524.     MBAinc--;
  526. #ifdef ENHANCEMENT
  527.     if (twostreams && enhan.scalable_mode==SC_SNR){
  528.       SNRMBA++;
  529.       SNRMBAinc--;
  530.     }
  531. #endif
  532.   }
  533. }
  536. void LayerData::macroblock_modes(int *pmb_type, int *pstwtype, int *pstwclass,
  537.   int *pmotion_type, int *pmv_count, int *pmv_format, int *pdmv, int *pmvscale,
  538.   int *pdct_type)
  539. {
  540.   int mb_type;
  541.   int stwtype, stwcode, stwclass;
  542.   int motion_type(0), mv_count, mv_format, dmv, mvscale;
  543.   int dct_type;
  544.   static unsigned char stwc_table[3][4]
  545.     = { {6,3,7,4}, {2,1,5,4}, {2,5,7,4} };
  546.   static unsigned char stwclass_table[9]
  547.     = {0, 1, 2, 1, 1, 2, 3, 3, 4};
  549.   /* get macroblock_type */
  550.   mb_type = getMBtype();
  552.   if (fault) return;
  554.   /* get spatial_temporal_weight_code */
  555.   if (mb_type & MB_WEIGHT)
  556.   {
  557.     if (stwc_table_index==0)
  558.       stwtype = 4;
  559.     else
  560.     {
  561.       stwcode = input->getbits(2);
  562.       stwtype = stwc_table[stwc_table_index-1][stwcode];
  563.     }
  564.   }
  565.   else
  566.     stwtype = (mb_type & MB_CLASS4) ? 8 : 0;
  568.   /* derive spatial_temporal_weight_class (Table 7-18) */
  569.   stwclass = stwclass_table[stwtype];
  571.   /* get frame/field motion type */
  572.   if (mb_type & (MB_FORWARD|MB_BACKWARD)){
  573.     if (pict_struct==FRAME_PICTURE){ /* frame_motion_type */
  574.       motion_type = frame_pred_dct ? MC_FRAME : input->getbits(2);
  575. #ifdef TRACE
  576.       if (!frame_pred_dct && trace){
  577.         printf("frame_motion_type (");
  578.         printbits(motion_type,2,2);
  579.         printf("): %sn",motion_type==MC_FIELD?"Field":
  580.                          motion_type==MC_FRAME?"Frame":
  581.                          motion_type==MC_DMV?"Dual_Prime":"Invalid");
  582.       }
  583. #endif
  584.     }
  585.     else { /* field_motion_type */
  586.       motion_type = input->getbits(2);
  587. #ifdef TRACE
  588.       if (trace){
  589.         printf("field_motion_type (");
  590.         printbits(motion_type,2,2);
  591.         printf("): %sn",motion_type==MC_FIELD?"Field":
  592.                          motion_type==MC_16X8?"16x8 MC":
  593.                          motion_type==MC_DMV?"Dual_Prime":"Invalid");
  594.       }
  595. #endif
  596.     }
  597.   }
  598.   else if ((mb_type & MB_INTRA) && conceal_mv)
  599.   {
  600.     /* concealment motion vectors */
  601.     motion_type = (pict_struct==FRAME_PICTURE) ? MC_FRAME : MC_FIELD;
  602.   }
  604.   /* derive mv_count, mv_format and dmv, (table 6-17, 6-18) */
  605.   if (pict_struct==FRAME_PICTURE)
  606.   {
  607.     mv_count = (motion_type==MC_FIELD && stwclass<2) ? 2 : 1;
  608.     mv_format = (motion_type==MC_FRAME) ? MV_FRAME : MV_FIELD;
  609.   }
  610.   else
  611.   {
  612.     mv_count = (motion_type==MC_16X8) ? 2 : 1;
  613.     mv_format = MV_FIELD;
  614.   }
  616.   dmv = (motion_type==MC_DMV); /* dual prime */
  618.   /* field mv predictions in frame pictures have to be scaled */
  619.   mvscale = ((mv_format==MV_FIELD) && (pict_struct==FRAME_PICTURE));
  621.   /* get dct_type (frame DCT / field DCT) */
  622.   dct_type = (pict_struct==FRAME_PICTURE)
  623.              && (!frame_pred_dct)
  624.              && (mb_type & (MB_PATTERN|MB_INTRA))
  625.              ? input->getbits(1)
  626.              : 0;
  628. #ifdef TRACE
  629.   if (trace  && (pict_struct==FRAME_PICTURE)
  630.              && (!frame_pred_dct)
  631.              && (mb_type & (MB_PATTERN|MB_INTRA)))
  632.     printf("dct_type (%d): %sn",dct_type,dct_type?"Field":"Frame");
  633. #endif
  635.   /* return values */
  636.   *pmb_type = mb_type;
  637.   *pstwtype = stwtype;
  638.   *pstwclass = stwclass;
  639.   *pmotion_type = motion_type;
  640.   *pmv_count = mv_count;
  641.   *pmv_format = mv_format;
  642.   *pdmv = dmv;
  643.   *pmvscale = mvscale;
  644.   *pdct_type = dct_type;
  645. }
  648. /* set block to zero */
  649. void LayerData::clearblock(int comp,int size){
  650.   sparse[comp] = 1;
  651.   memset(block[comp],0,sizeof(short)*64*size);
  652. }
  655. #ifdef ENHANCEMENT
  656. /* add SNR enhancement layer block data to base layer */
  658. void LayerData::sumblock(int comp){
  659.   short *bp1, *bp2;
  661.   bp1 = block[comp];
  662. #ifdef ENHANCEMANT
  663.   bp2 = enhan.block[comp];
  664. #endif
  665.   for (int i=0; i<64; i++) *bp1++ += *bp2++;
  666. }
  667. #endif
  669. /* limit coefficients to -2048..2047 */
  671. /* move/add 8x8-Block from block[comp] to refframe */
  673. void LayerData::addblock(int comp, int bx, int by, int dct_type, int addflag){
  674.   int cc,i, iincr;
  675.   unsigned char *rfp;
  676.   short *bp;
  677.   int spar = sparse[comp];
  678. #ifndef HAVE_MMX
  679.   unsigned char *clp2=display->getClpTable();
  681.   if (!addflag) clp2 += 128;
  682. #endif
  684.   cc = (comp<4) ? 0 : (comp&1)+1; /* color component index */
  686.   if (cc==0){   /* luminance */
  688.     if (pict_struct==FRAME_PICTURE)
  689.       if (dct_type){
  690.         /* field DCT coding */
  691.         rfp = newframe[0]
  692.               + coded_picture_width*(by+((comp&2)>>1)) + bx + ((comp&1)<<3);
  693.         iincr = (coded_picture_width<<1);
  694.       }
  695.       else{
  696.         /* frame DCT coding */
  697.         rfp = newframe[0]
  698.               + coded_picture_width*(by+((comp&2)<<2)) + bx + ((comp&1)<<3);
  699.         iincr = coded_picture_width;
  700.       }
  701.     else {
  702.       /* field picture */
  703.       rfp = newframe[0]
  704.             + (coded_picture_width<<1)*(by+((comp&2)<<2)) + bx + ((comp&1)<<3);
  705.       iincr = (coded_picture_width<<1);
  706.     }
  707.   }
  708.   else {
  709.     /* chrominance */
  711.     /* scale coordinates */
  712.     if (chroma_format!=CHROMA444)  bx >>= 1;
  713.     if (chroma_format==CHROMA420)  by >>= 1;
  714.     if (pict_struct==FRAME_PICTURE){
  715.       if (dct_type && (chroma_format!=CHROMA420)){
  716.         /* field DCT coding */
  717.         rfp = newframe[cc]
  718.               + chrom_width*(by+((comp&2)>>1)) + bx + (comp&8);
  719.         iincr = (chrom_width<<1);
  720.       }
  721.       else {
  722.         /* frame DCT coding */
  723.         rfp = newframe[cc]
  724.               + chrom_width*(by+((comp&2)<<2)) + bx + (comp&8);
  725.         iincr = chrom_width;
  726.       }
  727.     }
  728.     else {
  729.       /* field picture */
  730.       rfp = newframe[cc]
  731.             + (chrom_width<<1)*(by+((comp&2)<<2)) + bx + (comp&8);
  732.       iincr = (chrom_width<<1);
  733.     }
  734.   }
  736.   bp = block[comp];
  738.   if (addflag) {
  739. #ifdef HAVE_MMX
  740.     if (spar) {
  741.        __asm__ __volatile__(
  742.             "movq       (%2),%%mm6n"  /* 4 blockvals */
  743.             "pxor       %%mm4,%%mm4n"
  744.             "punpcklwd  %%mm6,%%mm6n"
  745.             "punpcklwd  %%mm6,%%mm6n"
  746.             ".align 8n"
  747.             "1:"
  748.                 "movq       (%1),  %%mm0n"     /* 8 rindex1 */
  749.                 "movq       %%mm0, %%mm2n"
  750.                 "punpcklbw  %%mm4, %%mm0n"
  751.                 "punpckhbw  %%mm4, %%mm2n"
  752.                 "paddw      %%mm6, %%mm0n"
  753.                 "paddw      %%mm6, %%mm2n"
  755.                 "packuswb   %%mm2, %%mm0n"
  756.                 "movq       %%mm0, (%1)n"
  758.                 "leal       (%1,%3), %1n"
  759.               "loop       1bn"
  760.               :              /* scr   dest */
  761.               : "c" (8),"r" (rfp), "r" (bp), "r" (iincr)
  762.                 );
  763.     }
  764.     else {
  765.        __asm__ __volatile__(
  766.          "pxor    %%mm4,%%mm4n"
  768.          ".align 8n"
  769.          "1:"
  770.            "movq       (%2), %%mm0n"   /* 8 rfp 0 1 2 3 4 5 6 7*/
  771.            "movq       (%1), %%mm6n"   /* 4 blockvals 0 1 2 3 */
  773.            "movq       %%mm0, %%mm2n"
  774.            "movq       8(%1), %%mm5n"  /* 4 blockvals 0 1 2 3 */
  775.            "punpcklbw  %%mm4, %%mm0n"  /* 0 2 4 6 */
  776.            "punpckhbw  %%mm4, %%mm2n"  /* 1 3 5 7 */
  778.            "paddw      %%mm6, %%mm0n"
  779.            "paddw      %%mm5, %%mm2n"
  780.            "packuswb   %%mm2, %%mm0n"
  782.            "addl       $16, %1n"
  783.            "movq       %%mm0, (%2)n"
  785.            "leal       (%2,%3), %2n"
  786.          "loop       1bn"
  787.          :              /* scr   dest */
  788.          : "c" (8),"r" (bp), "r" (rfp), "r" (iincr)
  789.        );
  791. //      add_block_mmx(rfp,bp,iincr);
  792.     }
  793. #else
  794.     for (i=0; i<8; i++){
  795.       rfp[0] = clp2[bp[0] + rfp[0]];
  796.       rfp[1] = clp2[bp[1] + rfp[1]];
  797.       rfp[2] = clp2[bp[2] + rfp[2]];
  798.       rfp[3] = clp2[bp[3] + rfp[3]];
  799.       rfp[4] = clp2[bp[4] + rfp[4]];
  800.       rfp[5] = clp2[bp[5] + rfp[5]];
  801.       rfp[6] = clp2[bp[6] + rfp[6]];
  802.       rfp[7] = clp2[bp[7] + rfp[7]];
  803.       rfp+= iincr;
  804.       bp += 8;
  805.     }
  806. #endif
  807.   }
  808.   else {
  809. #ifdef HAVE_MMX
  810.      if (spar) {
  811.             __asm__ __volatile__(
  812.             "movd       (%2),           %%mm0n"                // " 0 0 0  v1"
  813.             "punpcklwd  %%mm0,          %%mm0n"    // " 0 0 v1 v1"
  814.             "punpcklwd  %%mm0,          %%mm0n"
  815.             "paddw      MMX_128,        %%mm0n"
  816.             "packuswb   %%mm0,          %%mm0n"
  817.             "leal       (%0,%1,2),      %%eaxn"
  819.             "movq        %%mm0,         (%0, %1)n"
  820.             "movq        %%mm0,         (%%eax)n"
  821.             "leal        (%%eax,%1,2),  %0n"
  822.             "movq        %%mm0,         (%%eax, %1)n"
  824.             "movq        %%mm0,         (%0)n"
  825.             "leal        (%0,%1,2),     %%eaxn"
  826.             "movq        %%mm0,         (%0, %1)n"
  828.             "movq        %%mm0,         (%%eax)n"
  829.             "movq        %%mm0,         (%%eax, %1)n"
  830.             :
  831.             : "D" (rfp), "c" (iincr), "b" (bp)
  832.             : "eax");
  833.     }
  834.     else {
  836.        __asm__ __volatile__(
  837.             "movq        MMX_128,%%mm4n"
  838.             ".align 8n"
  839.             "1:"
  840.               "movq      (%1),   %%mm0n"
  841.               "movq      8(%1),  %%mm1n"
  842.               "paddw     %%mm4,  %%mm0n"
  844.               "movq      16(%1), %%mm2n"
  845.               "paddw     %%mm4,  %%mm1n"
  847.               "movq      24(%1), %%mm3n"
  848.               "paddw     %%mm4,  %%mm2n"
  850.               "packuswb  %%mm1,  %%mm0n"
  851.               "paddw     %%mm4,  %%mm3n"
  853.               "addl $32, %1n"
  854.               "packuswb  %%mm3,  %%mm2n"
  856.               "movq   %%mm0, (%2)n"
  858.               "movq   %%mm2, (%2,%3)n"
  860.               "leal       (%2,%3,2), %2n"
  861.             "loop       1bn"
  862.             :
  863.             : "c" (4), "r" (bp), "r" (rfp), "r" (iincr)
  864.         );
  866. //      set_block_mmx(rfp,bp,iincr);
  867.     }
  868. #else
  869.     for (i=0; i<8; i++){
  870.       rfp[0] = clp2[bp[0]];
  871.       rfp[1] = clp2[bp[1]];
  872.       rfp[2] = clp2[bp[2]];
  873.       rfp[3] = clp2[bp[3]];
  874.       rfp[4] = clp2[bp[4]];
  875.       rfp[5] = clp2[bp[5]];
  876.       rfp[6] = clp2[bp[6]];
  877.       rfp[7] = clp2[bp[7]];
  878.       rfp+= iincr;
  879.       bp += 8;
  880.     }
  881. #endif
  882.   }
  883. }