mpeg_sc.cpp

H.264完整的C语言代码和DCT的代码

    im_stream<im_half2> NAMED(CrCbMVref) = newStreamData<im_half2>(num_MB*2*8*8/2); 
    im_stream<im_half2> NAMED(Ydiff)     = newStreamData<im_half2>(num_MB*4*64/2); 
    im_stream<im_half2> NAMED(CrCbdiff)  = newStreamData<im_half2>(num_MB*2*64/2); 

    im_stream<im_half2>  NAMED(rowMV) = newStreamData<im_half2>(mpeg_rtny(mb_width*2, 8)); 
    im_stream<im_ubyte4> NAMED(row0) = newStreamData<im_ubyte4>(mb_width*16*16/4); 
    im_stream<im_ubyte4> NAMED(row1) = newStreamData<im_ubyte4>(mb_width*16*16/4); 
    im_stream<im_ubyte4> NAMED(row2) = newStreamData<im_ubyte4>(mb_width*16*16/4); 
    im_stream<im_ubyte4> NAMED(mblks) = newStreamData<im_ubyte4>(mb_width*16*16/4);

    im_stream<im_int> NAMED(idx_gen_str);

    im_stream<im_half2> NAMED(zerolen_str) = newStreamData<im_half2>(0);


    //此处添加
	int rlen = mb_width*16*16/4;
    im_stream<im_ubyte4> r0(rlen), r1(rlen), r2(rlen);
	bool firstRow = 0;
    bool lastRow = 0;
	int ref_idx = 2*rlen;

    
	
	if (byrow)
    {
      int rlen = mb_width*16*16/4;
      int run_levels_pos = 0;
      int last_idx_type = -1;

      im_stream<im_half2>  NAMED(rowRunLevels);

      for (int row = 0; row < mb_height; row++)
      // for_FIXED (int row = 0; row < mb_height; row++)
      {
        // loopIter(row == 0 || row == mb_height - 1, (row % 2) == 1);

        int idx_type = (row == mb_height - 1 ? lasttype : lastcoltype);
        if (last_idx_type == -1 || last_idx_type != idx_type) {
          im_uc<im_int> idx_params = (idx_type << 16) + mb_width;
          idx_gen_str = newStreamData<im_int>(mb_width*16*16);
          idxGen(idx_gen_str, image_size_param, idx_params);
          last_idx_type = idx_type;
        }
  
        fa = row*16*iwidth;
        im_stream<im_ubyte4> NAMED(rowInput) = 
          newStreamData<im_ubyte4>(mb_width*16*16);
        im_stream<im_ubyte4> NAMED(rowY1blk) =
          Y1blk(row*(mb_width*16*16/4), (row+1)*(mb_width*16*16/4));
        im_stream<im_half2>  NAMED(rowCrCb1dct) = 
          CrCb1dct(row*(mb_width*2*64/2), (row+1)*(mb_width*2*64/2));
        im_stream<im_half2>  NAMED(rowMV) = 
          MV(row*(mb_width*2), row*(mb_width*2) + mpeg_rtny(mb_width*2, 8));
        im_stream<im_uint>   NAMED(rowYidx) = 
          Yidx(row*(mb_width*16*16/4), (row+1)*(mb_width*16*16/4));
        im_stream<im_uint>   NAMED(rowCrCbidx) = 
          CrCbidx(row*(mb_width*2*8*8/2), (row+1)*(mb_width*2*8*8/2));
        im_stream<im_ubyte4> NAMED(rowYMVref) = 
          YMVref(row*(mb_width*4*8*8/4), (row+1)*(mb_width*4*8*8/4));
        im_stream<im_half2>  NAMED(rowCrCbMVref) = 
          CrCbMVref(row*(mb_width*2*8*8/2), (row+1)*(mb_width*2*8*8/2));
        im_stream<im_half2>  NAMED(rowYdiff) = 
          Ydiff(row*(mb_width*4*64/2), (row+1)*(mb_width*4*64/2));
        im_stream<im_half2>  NAMED(rowCrCbdiff) = 
          CrCbdiff(row*(mb_width*2*64/2), (row+1)*(mb_width*2*64/2));
        im_stream<im_half2>  NAMED(rowY2rle) = 
          Y2rle(row*(mb_width*4*64/2), (row+1)*(mb_width*4*64/2));
        im_stream<im_half2>  rowCrCb2rle = 
          CrCb2rle(row*(mb_width*2*64/2), (row+1)*(mb_width*2*64/2));
        im_stream<im_half2>  NAMED(rowY3) = 
          Y3(row*(mb_width*4*64/2), (row+1)*(mb_width*4*64/2));
        im_stream<im_half2>  NAMED(rowCrCb3) = 
          CrCb3(row*(mb_width*2*64/2), (row+1)*(mb_width*2*64/2));
        im_stream<im_ubyte4> NAMED(rowYref) = 
          Yref(row*(mb_width*4*8*8/4), (row+1)*(mb_width*4*8*8/4));
        im_stream<im_half2>  NAMED(rowCrCbref) = 
          CrCbref(row*(mb_width*2*8*8/2), (row+1)*(mb_width*2*8*8/2));
        im_stream<im_ubyte4> NAMED(rowYref2) = 
          Yref2(row*(mb_width*4*8*8/4), (row+1)*(mb_width*4*8*8/4));
        im_stream<im_half2>  NAMED(rowCrCbref2) = 
          CrCbref2(row*(mb_width*2*8*8/2), (row+1)*(mb_width*2*8*8/2));

        streamCopy(image(fa, ilen, im_var_pos, im_acc_index, idx_gen_str),
          rowInput);

        pcolor(rowInput, rowY1blk, rowCrCb1dct);


        streamSaveFile("h264/row0.txt", "txt", "x2", row0);
		streamSaveFile("h264/row1.txt", "txt", "x2", row1);
		streamSaveFile("h264/row2.txt", "txt", "x2", row2);
		streamSaveFile("h264/rowY1blk.txt", "txt", "x2", rowY1blk);




        //此处修改！
        im_uc<im_int> margin = ( firstRow ? 0 : 0x10 ) | ( lastRow ? 0 : 0x1000 );
        im_uc<im_int> offsets ((row*16) << 16);
        im_uc<im_int> num_mb = mb_width;
        if ( (row % 3) == 0 ) {
          me_fast_search4(row0, row1, row2, rowY1blk, rowMV, margin, num_mb);
          me_fast_jitter2(row0, row1, row2, rowY1blk, rowMV, rowMV, margin, num_mb);
          me_fast_jitter1(row0, row1, row2, rowY1blk, rowMV, rowMV, rowYMVref, rowCrCbidx, margin, offsets, num_mb, num_mb);
          streamCopy(Yref(ref_idx, ref_idx+rlen), r0);
		} else if ( (row % 3) == 1 ) {
          me_fast_search4(row1, row2, row0, rowY1blk, rowMV, margin, num_mb);
          me_fast_jitter2(row1, row2, row0, rowY1blk, rowMV, rowMV, margin, num_mb);
          me_fast_jitter1(row1, row2, row0, rowY1blk, rowMV, rowMV, rowYMVref, rowCrCbidx, margin, offsets, num_mb, num_mb);
		  streamCopy(Yref(ref_idx, ref_idx+rlen), r1);      
		} else if ( (row % 3) == 2 ) {
          me_fast_search4(row2, row0, row1, rowY1blk, rowMV, margin, num_mb);
          me_fast_jitter2(row2, row0, row1, rowY1blk, rowMV, rowMV, margin, num_mb);
          me_fast_jitter1(row2, row0, row1, rowY1blk, rowMV, rowMV, rowYMVref, rowCrCbidx, margin, offsets, num_mb, num_mb);
          streamCopy(Yref(ref_idx, ref_idx+rlen), r2);
		}//row影响到kernel调用前3个参数的顺序
        ref_idx = (row >= (mb_height - 3)) ? ref_idx : ref_idx + rlen;

        
		streamSaveFile("h264/rowMV.txt", "txt", "x2", rowMV);

        
			
		row0 = (row == 0) 
          ? newStreamData<im_ubyte4>(mb_width*16*16/4)  // dummy
          : Yref((row-1)*rlen, row*rlen);
        row1 = Yref(row*rlen, (row+1)*rlen);
        row2 = (row == (mb_height - 1))
          ? newStreamData<im_ubyte4>(mb_width*16*16/4)  // dummy
          : Yref((row+1)*rlen, (row+2)*rlen);

        int loc = ( ( row == 0 ) ? 1 : 0 ) |
          ( ( row == mb_height - 1 ) ? 2 : 0 );

		//streamSaveFile("mpeg_sc/row0.txt", "txt", "x2", row0);
		//streamSaveFile("mpeg_sc/row1.txt", "txt", "x2", row1);
		//streamSaveFile("mpeg_sc/row2.txt", "txt", "x2", row2);
		//streamSaveFile("mpeg_sc/rowY1blk.txt", "txt", "x2", rowY1blk);

        //blocksearch(row0, row1, row2, rowY1blk, rowMV, im_uc<im_int>(loc));

		//streamSaveFile("mpeg_sc/motion.txt", "txt", "x2", rowMV);

        im_uc<im_int> mb1 = im_uc<im_int>(mb_width);
        im_uc<im_int> mb2 = im_uc<im_int>(mb_width);
        MV2idx(rowMV, rowYidx, rowCrCbidx, 
               im_uc<im_int>((row*16) << 16), mb1, mb2);

        rowYMVref = Yref(0, Yref.getLength(), 
                         false, im_acc_index, rowYidx);
        rowCrCbMVref = CrCbref(0, CrCbref.getLength(), 
                               false, im_acc_index, rowCrCbidx);

        difference(rowY1blk, rowCrCb1dct, rowYMVref, rowCrCbMVref, 
                   rowYdiff, rowCrCbdiff);

        dct(rowYdiff, dct_non_intra_consts, rowY2rle, quantizer_scale);
        dct(rowCrCbdiff, dct_non_intra_consts, rowCrCb2rle, quantizer_scale);

        // Keep track of current position in run_levels so that we
        // can append to the stream correctly - hopefully Peter will
        // make this work nicer someday.
        if (row != 0) {
          run_levels_pos += rowRunLevels.getLength();
        }
        rowRunLevels =
          run_levels(run_levels_pos, run_levels.getLength(), 
          im_countup | im_var_pos | im_var_size);
        rle(rowY2rle, rowCrCb2rle, rle_consts, rowMV, rowRunLevels, pframe,
            qs);

        // save run levels to memory as output frame

        idct(rowY2rle, idct_non_intra_consts, rowY3, iquantizer_scale);
        idct(rowCrCb2rle, idct_non_intra_consts, rowCrCb3, iquantizer_scale);

        correlate(rowY3, rowCrCb3, rowYMVref, rowCrCbMVref, 
                  rowYref2, rowCrCbref2, pframe);
      }
    }
    else
    {
      if (dumpfiles)
      {
        sprintf(outfilename, "mpeg_sc/pinput%d.txt", i);
        streamSaveFile(outfilename, "txt", "x4", Input);
      }

      // COLOR
      if (!pcref) {
        pcolor(Input, Y1blk, CrCb1dct);
      } else {
        pcolorref(scd, n, Y1blk, CrCb1dct);
      }

      if (dumpfiles)
      {
        sprintf(outfilename, "mpeg_sc/ypcolor%d.txt", i);
        streamSaveFile(outfilename, "txt", "x4", Y1blk);
        sprintf(outfilename, "mpeg_sc/cpcolor%d.txt", i);
        streamSaveFile(outfilename, "txt", "x2", CrCb1dct);
      }

      // Blocksearch
      if (!bsref) {
        int rlen = mb_width*16*16/4;
        row0 = row1 = row2 = Yref(0, rlen);
        for (int row = 0; row < mb_height; row++)
        {
          row0 = row1;
          row1 = row2;
          row2 = ((row != (mb_height - 1)) ?
                  Yref((row+1)*rlen, (row+2)*rlen) : row1);
          mblks = Y1blk(row*rlen, (row+1)*rlen);
          rowMV = MV(row*mb_width*2, row*mb_width*2 + mpeg_rtny(mb_width*2, 8));

          //int loc = ( row == 0 ) | ( ( row == mb_height-1 ) << 1 );
          int loc = ( ( row == 0 ) ? 1 : 0 ) |
            ( ( row == mb_height - 1 ) ? 2 : 0 );

          //blocksearch(row0, row1, row2, mblks, rowMV, im_uc<im_int>(loc) );
        }
      } else {
        blocksearchref(scd, Y1blk, Yref, MV);
      }

      if (dumpfiles)
      {
        sprintf(outfilename, "mpeg_sc/mv%d.txt", i);
        streamSaveFile(outfilename, "txt", "x2", MV);
      }

      // Get original macroblocks and difference them with current macroblocks
      if (!mvref) {
        for (int row = 0; row < mb_height; row++)
        {
          int rlen = mb_width*16*16/4;
          im_stream<im_half2> NAMED(rowMV) = MV(row*mb_width*2, (row+1)*mb_width*2);
          im_stream<im_uint>  NAMED(rowYidx)    = Yidx(row*rlen, (row+1)*rlen);
          im_stream<im_uint>  NAMED(rowCrCbidx) = CrCbidx(row*rlen, (row+1)*rlen);

          im_uc<im_int> mb1 = im_uc<im_int>(mb_width);
          im_uc<im_int> mb2 = im_uc<im_int>(mb_width);
          MV2idx(rowMV, rowYidx, rowCrCbidx, 
                 im_uc<im_int>((row*16) << 16), mb1, mb2);
        }
      } else {
        mv2idxref(scd, MV, Yidx, CrCbidx, width);
      }

      if (dumpfiles)
      {
        sprintf(outfilename, "mpeg_sc/yidx%d.txt", i);
        streamSaveFile(outfilename, "txt", "x", Yidx);
        sprintf(outfilename, "mpeg_sc/cidx%d.txt", i);
        streamSaveFile(outfilename, "txt", "x", CrCbidx);
      }

      YMVref = Yref(0, Yref.getLength(), false, im_acc_index, Yidx);
      CrCbMVref = CrCbref(0, CrCbref.getLength(), false, im_acc_index, CrCbidx);

      if (dumpfiles)
      {
        sprintf(outfilename, "mpeg_sc/ymvref%d.txt", i);
        streamSaveFile(outfilename, "txt", "x4", YMVref);
        sprintf(outfilename, "mpeg_sc/cmvref%d.txt", i);
        streamSaveFile(outfilename, "txt", "x2", CrCbMVref);
      }

      difference(Y1blk, CrCb1dct, YMVref, CrCbMVref, Ydiff, CrCbdiff);

      if (dumpfiles)
      {
        sprintf(outfilename, "mpeg_sc/ydiff%d.txt", i);
        streamSaveFile(outfilename, "txt", "x2", Ydiff);
        sprintf(outfilename, "mpeg_sc/cdiff%d.txt", i);
        streamSaveFile(outfilename, "txt", "x2", CrCbdiff);
      }

      // DCT
      if (!dref) {
        // streamLoadVect(dct_non_intra_consts_v, dct_non_intra_consts);
        dct(Ydiff, dct_non_intra_consts, qref ? Y2:Y2rle, quantizer_scale);
        // streamLoadVect(dct_non_intra_consts_v, dct_non_intra_consts);
        dct(CrCbdiff, dct_non_intra_consts, qref ? CrCb2:CrCb2rle,
            quantizer_scale);
      } else {
        dctref(scd, Ydiff, Y2);
        dctref(scd, CrCbdiff, CrCb2);
      }
      if (qref) {
        quantref(scd, Y2, Y2rle, quant_scale, false);
        quantref(scd, CrCb2, CrCb2rle, quant_scale, false);
      }

      if (dumpfiles)
      {
        sprintf(outfilename, "mpeg_sc/ypdct%d.txt", i);
        streamSaveFile(outfilename, "txt", "x2", Y2rle);
        sprintf(outfilename, "mpeg_sc/cpdct%d.txt", i);
        streamSaveFile(outfilename, "txt", "x2", CrCb2rle);
      }

      // IDCT
      if (iqref) {
        iquantref(scd, Y2rle, Y2, quant_scale, false);
        iquantref(scd, CrCb2rle, CrCb2, quant_scale, false);
      }
      if (!idref) {
        // streamLoadVect(idct_non_intra_consts_v, idct_non_intra_consts);
        idct(iqref ? Y2:Y2rle, idct_non_intra_consts, Y3, iquantizer_scale);
        // streamLoadVect(idct_non_intra_consts_v, idct_non_intra_consts);
        idct(iqref ? CrCb2:CrCb2rle, idct_non_intra_consts, CrCb3, iquantizer_scale);
      } else {
        idctref(scd, Y2, Y3);
        idctref(scd, CrCb2, CrCb3);
      }

      if (dumpfiles)
      {
        sprintf(outfilename, "mpeg_sc/ypidct%d.txt", i);
        streamSaveFile(outfilename, "txt", "x2", Y3);
        sprintf(outfilename, "mpeg_sc/cpidct%d.txt", i);
        streamSaveFile(outfilename, "txt", "x2", CrCb3);
      }

      // Correlate
      correlate(Y3, CrCb3, YMVref, CrCbMVref, Yref2, CrCbref2, pframe);

      if (dumpfiles)
      {
        sprintf(outfilename, "mpeg_sc/ypref%d.txt", i);
        streamSaveFile(outfilename, "txt", "x4", Yref);
        sprintf(outfilename, "mpeg_sc/cpref%d.txt", i);
        streamSaveFile(outfilename, "txt", "x2", CrCbref);
      }
    }
}


void mpeg_macro(StreamSchedulerInterface& scd, String args)
{
  char *s = args.char_ptr();
  char *s2 = s;

  String parmfile = get_next_word(&s);
  String parm2 = get_next_word(&s);
  String parm3 = get_next_word(&s);

  bool encode_isim = (parm2 == "encode_isim");
  
  args.delete_char_ptr(s2);

  // idct_test();
  // pframe_test();
  // mv2idx_test();
  // pcolor_test();
  // diff_test();
  // corr_test();
  // blocksearch_test();
  // return;

  readparmfile(parmfile.char_ptr());

  char tplorg2[256];