mpeg_sc.cpp

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

  int xy, yy, xc, yc, offset, idx;
  yy = 0;
  yc = 0;
  int mb_width = rowlen/16;
  for (i = 0; i < vm.size() / 2; i++) {
    if (i % mb_width == 0) {
      xy = 0;
      xc = 0;
    }
    int dx = vm[2*i] & 0xffff;
    int dy = vm[2*i] >> 16;
    for (k = 0; k < 256; k+=4) {
      int x2y = xy + ((k/4)/16)*4 + k%4;
      int y2y = yy + (k/4)%16;
      offset = get_offset_y(x2y + dx, y2y + dy, rowlen);
      idx = (i*16*16 + k)/4;
      vyi[idx] = offset;
    }
    for (k = 0; k < 64; k++) {
      int x2c = xc + k%8;
      int y2c = yc + k/8;
      offset = get_offset_c(x2c + dx/2, y2c + dy/2, rowlen/2);
      idx = i*2*8*8/2 + k;
      vci[idx] = offset;
    }
    xy += 16;
    xc += 8;
    if (i % mb_width == (mb_width-1)) {
      yy += 16;
      yc += 8;
    }
  }
  streamLoadVect(vyi, yindices);
  streamLoadVect(vci, crcbindices);
}

void diff_test(StreamSchedulerInterface& scd)
{
  vector<unsigned int> difference_test;
  vector<unsigned int> neg128;
  vector<unsigned int> zero_ref(64, 0);

  difference_test.push_back(0x00010203);
  difference_test.push_back(0x10111213);
  difference_test.push_back(0x20212223);
  difference_test.push_back(0x30313233);
  difference_test.push_back(0x40414243);
  difference_test.push_back(0x50515253);
  difference_test.push_back(0x60616263);
  difference_test.push_back(0x70717273);
  difference_test.push_back(0x80818283);
  difference_test.push_back(0x90919293);
  difference_test.push_back(0xa0a1a2a3);
  difference_test.push_back(0xb0b1b2b3);
  difference_test.push_back(0xc0c1c2c3);
  difference_test.push_back(0xd0d1d2d3);
  difference_test.push_back(0xe0e1e2e3);
  difference_test.push_back(0xf0f1f2f3);

  difference_test.push_back(0x04050607);
  difference_test.push_back(0x14151617);
  difference_test.push_back(0x24252627);
  difference_test.push_back(0x34353637);
  difference_test.push_back(0x44454647);
  difference_test.push_back(0x54555657);
  difference_test.push_back(0x64656667);
  difference_test.push_back(0x74757677);
  difference_test.push_back(0x84858687);
  difference_test.push_back(0x94959697);
  difference_test.push_back(0xa4a5a6a7);
  difference_test.push_back(0xb4b5b6b7);
  difference_test.push_back(0xc4c5c6c7);
  difference_test.push_back(0xd4d5d6d7);
  difference_test.push_back(0xe4e5e6e7);
  difference_test.push_back(0xf4f5f6f7);

  difference_test.push_back(0x08090a0b);
  difference_test.push_back(0x18191a1b);
  difference_test.push_back(0x28292a2b);
  difference_test.push_back(0x38393a3b);
  difference_test.push_back(0x48494a4b);
  difference_test.push_back(0x58595a5b);
  difference_test.push_back(0x68696a6b);
  difference_test.push_back(0x78797a7b);
  difference_test.push_back(0x88898a8b);
  difference_test.push_back(0x98999a9b);
  difference_test.push_back(0xa8a9aaab);
  difference_test.push_back(0xb8b9babb);
  difference_test.push_back(0xc8c9cacb);
  difference_test.push_back(0xd8d9dadb);
  difference_test.push_back(0xe8e9eaeb);
  difference_test.push_back(0xf8f9fafb);

  difference_test.push_back(0x0c0d0e0f);
  difference_test.push_back(0x1c1d1e1f);
  difference_test.push_back(0x2c2d2e2f);
  difference_test.push_back(0x3c3d3e3f);
  difference_test.push_back(0x4c4d4e4f);
  difference_test.push_back(0x5c5d5e5f);
  difference_test.push_back(0x6c6d6e6f);
  difference_test.push_back(0x7c7d7e7f);
  difference_test.push_back(0x8c8d8e8f);
  difference_test.push_back(0x9c9d9e9f);
  difference_test.push_back(0xacadaeaf);
  difference_test.push_back(0xbcbdbebf);
  difference_test.push_back(0xcccdcecf);
  difference_test.push_back(0xdcdddedf);
  difference_test.push_back(0xecedeeef);
  difference_test.push_back(0xfcfdfeff);

  vector<unsigned int> crcb_test;
  for (int ci = 0; ci<64; ci++)
  {
    crcb_test.push_back(ci | ci << 24);
    neg128.push_back(0xffffffff);
  }

  im_stream<im_ubyte4> curryblks_test = newStreamData<im_ubyte4>(10000, true);
  streamLoadVect(difference_test, curryblks_test);
  im_stream<im_ubyte4> refyblks_test = newStreamData<im_ubyte4>(10000, true);
  streamLoadVect(neg128, refyblks_test);

  im_stream<im_half2> currcblks_test = newStreamData<im_half2>(10000, true);
  streamLoadVect(crcb_test, currcblks_test);
  im_stream<im_half2> refcblks_test = newStreamData<im_half2>(10000, true);
  streamLoadVect(zero_ref, refcblks_test);

  im_stream<im_half2> diffyblks_test = newStreamData<im_half2>(10000, true);
  im_stream<im_half2> diffcblks_test = newStreamData<im_half2>(10000, true);

  difference(curryblks_test, currcblks_test, refyblks_test, refcblks_test,
             diffyblks_test, diffcblks_test);

  streamSaveFile("mpeg_sc/diffy.txt", "txt", "x2", diffyblks_test);
  streamSaveFile("mpeg_sc/currc.txt", "txt", "x2", currcblks_test);
  streamSaveFile("mpeg_sc/diffc.txt", "txt", "x2", diffcblks_test);
}

void pcolor_test(StreamSchedulerInterface& scd)
{
  int i;

  char pfile[256] = "test.par";
  readparmfile(pfile);
  mpeg_init();

  FILE *f;
  f = fopen("mpeg_sc/test0.ppm", "wb");
  fprintf(f, "P6\n#test0.ppm -- ujk, 3-8-00\n16 16\n255");
  i = 10;
  fwrite(&i, sizeof(char), 1, f);
  for (i = 0; i < 256; i++) {
    fwrite(&i, sizeof(char), 1, f);
    fwrite(&i, sizeof(char), 1, f);
    fwrite(&i, sizeof(char), 1, f);
  }
  fclose(f);  

  im_stream<im_ubyte4> yout = newStreamData<im_ubyte4>(256/4);
  im_stream<im_half2> cout = newStreamData<im_half2>(256/4/2);
  pcolorref(scd, 0, yout, cout);
  streamSaveFile("mpeg_sc/yout.txt", "txt", "x4", yout);
  streamSaveFile("mpeg_sc/cout.txt", "txt", "x2", cout);

  im_stream<im_half2> youti = newStreamData<im_half2>(256/2);
  im_stream<im_half2> couti = newStreamData<im_half2>(256/4/2);
  icolorref(scd, 0, youti, couti);
  streamSaveFile("mpeg_sc/iyout.txt", "txt", "x2", youti);
  streamSaveFile("mpeg_sc/icout.txt", "txt", "x2", couti);
}

void mv2idx_test(StreamSchedulerInterface& scd)
{
  vector<unsigned int> m(1*2);
  m[0] = 0x00040004;

  im_stream<im_half2> mv = newStreamData<im_half2>(m.size());
  streamLoadVect(m, mv);
  im_stream<im_uint> yi = newStreamData<im_uint>((m.size()/2)*16*16/4);
  im_stream<im_uint> ci = newStreamData<im_uint>((m.size()/2)*2*8*8/2);
  mv2idxref(scd, mv, yi, ci, 1024);
  streamSaveFile("mpeg_sc/yi.txt", "txt", "x", yi);
  streamSaveFile("mpeg_sc/ci.txt", "txt", "x", ci);
}

void corr_test(StreamSchedulerInterface& scd)
{
  vector<unsigned int> correlate_test;
  vector<unsigned int> half2_test;
  vector<unsigned int> neg128;
  vector<unsigned int> zero_ref128(128, 0);
  vector<unsigned int> zero_ref64(64, 0);

  correlate_test.push_back(0x00010203);
  correlate_test.push_back(0x10111213);
  correlate_test.push_back(0x20212223);
  correlate_test.push_back(0x30313233);
  correlate_test.push_back(0x40414243);
  correlate_test.push_back(0x50515253);
  correlate_test.push_back(0x60616263);
  correlate_test.push_back(0x70717273);
  correlate_test.push_back(0x80818283);
  correlate_test.push_back(0x90919293);
  correlate_test.push_back(0xa0a1a2a3);
  correlate_test.push_back(0xb0b1b2b3);
  correlate_test.push_back(0xc0c1c2c3);
  correlate_test.push_back(0xd0d1d2d3);
  correlate_test.push_back(0xe0e1e2e3);
  correlate_test.push_back(0xf0f1f2f3);

  correlate_test.push_back(0x04050607);
  correlate_test.push_back(0x14151617);
  correlate_test.push_back(0x24252627);
  correlate_test.push_back(0x34353637);
  correlate_test.push_back(0x44454647);
  correlate_test.push_back(0x54555657);
  correlate_test.push_back(0x64656667);
  correlate_test.push_back(0x74757677);
  correlate_test.push_back(0x84858687);
  correlate_test.push_back(0x94959697);
  correlate_test.push_back(0xa4a5a6a7);
  correlate_test.push_back(0xb4b5b6b7);
  correlate_test.push_back(0xc4c5c6c7);
  correlate_test.push_back(0xd4d5d6d7);
  correlate_test.push_back(0xe4e5e6e7);
  correlate_test.push_back(0xf4f5f6f7);

  correlate_test.push_back(0x08090a0b);
  correlate_test.push_back(0x18191a1b);
  correlate_test.push_back(0x28292a2b);
  correlate_test.push_back(0x38393a3b);
  correlate_test.push_back(0x48494a4b);
  correlate_test.push_back(0x58595a5b);
  correlate_test.push_back(0x68696a6b);
  correlate_test.push_back(0x78797a7b);
  correlate_test.push_back(0x88898a8b);
  correlate_test.push_back(0x98999a9b);
  correlate_test.push_back(0xa8a9aaab);
  correlate_test.push_back(0xb8b9babb);
  correlate_test.push_back(0xc8c9cacb);
  correlate_test.push_back(0xd8d9dadb);
  correlate_test.push_back(0xe8e9eaeb);
  correlate_test.push_back(0xf8f9fafb);

  correlate_test.push_back(0x0c0d0e0f);
  correlate_test.push_back(0x1c1d1e1f);
  correlate_test.push_back(0x2c2d2e2f);
  correlate_test.push_back(0x3c3d3e3f);
  correlate_test.push_back(0x4c4d4e4f);
  correlate_test.push_back(0x5c5d5e5f);
  correlate_test.push_back(0x6c6d6e6f);
  correlate_test.push_back(0x7c7d7e7f);
  correlate_test.push_back(0x8c8d8e8f);
  correlate_test.push_back(0x9c9d9e9f);
  correlate_test.push_back(0xacadaeaf);
  correlate_test.push_back(0xbcbdbebf);
  correlate_test.push_back(0xcccdcecf);
  correlate_test.push_back(0xdcdddedf);
  correlate_test.push_back(0xecedeeef);
  correlate_test.push_back(0xfcfdfeff);

  for (int rcnt=0; rcnt<16; rcnt++)
    for (int ccnt=0; ccnt<8; ccnt++)
    {
      unsigned int high = rcnt * 16 + ccnt + 8;
      high = (high & 0x100) ? high | 0xff00 : high;
      unsigned int low = rcnt * 16 + ccnt;
      low = (low & 0x100) ? low | 0xff00 : low;
      half2_test.push_back((high << 16) | (low & 0xffff));
    }

  vector<unsigned int> crcb_test;
  for (int ci = 0; ci<64; ci++)
  {
    crcb_test.push_back(ci | ci << 24);
    neg128.push_back(0xffffffff);
  }

  im_stream<im_ubyte4> refyblks_test = newStreamData<im_ubyte4>(9*64);
  // streamLoadVect(correlate_test, refyblks_test);
  im_stream<im_half2> diffyblks_test = newStreamData<im_half2>(9*128);
  // streamLoadVect(zero_ref128, diffyblks_test);

  im_stream<im_half2> currcblks_test = newStreamData<im_half2>(9*64);
  // streamLoadVect(crcb_test, currcblks_test);
  im_stream<im_half2> refcblks_test = newStreamData<im_half2>(9*64);
  // streamLoadVect(zero_ref64, refcblks_test);

  im_stream<im_ubyte4> newrefyblks_test = newStreamData<im_ubyte4>(10000, true);
  im_stream<im_half2> newrefcblks_test = newStreamData<im_half2>(10000, true);

  
  im_uc<im_uint> pframe = (int)0xffffffff;

  /*
  correlate(diffyblks_test, currcblks_test, refyblks_test, refcblks_test,
            newrefyblks_test, newrefcblks_test, pframe);
  */

  // streamLoadVect(zero_ref64, refyblks_test);
  // streamLoadVect(half2_test, diffyblks_test);

  streamLoadFile("mpeg_sc/cmvref1.txt", "txt", "", refcblks_test);
  streamLoadFile("mpeg_sc/cpidct1.txt", "txt", "", currcblks_test);

  streamLoadFile("mpeg_sc/ymvref1.txt", "txt", "", refyblks_test);
  streamLoadFile("mpeg_sc/ypidct1.txt", "txt", "", diffyblks_test);

  correlate(diffyblks_test, currcblks_test, refyblks_test, refcblks_test,
            newrefyblks_test, newrefcblks_test, pframe);

  streamSaveFile("mpeg_sc/origrefy.txt", "txt", "x2", refyblks_test);
  streamSaveFile("mpeg_sc/origrefc.txt", "txt", "x2", refcblks_test);
  streamSaveFile("mpeg_sc/diffy.txt", "txt", "x2", diffyblks_test);
  streamSaveFile("mpeg_sc/diffc.txt", "txt", "x2", currcblks_test);
  streamSaveFile("mpeg_sc/newrefy.txt", "txt", "x2", newrefyblks_test);
  streamSaveFile("mpeg_sc/newrefc.txt", "txt", "x2", newrefcblks_test);
}

void pframe_test()
{
  int i, j, z, row, col;
  z = 0;
  FILE *f;
  f = fopen("mpeg_sc/test0.ppm", "wb");
  fprintf(f, "P6\n#test0.ppm -- ujk, 3-8-00\n32 32\n255");
  i = 10;
  fwrite(&i, sizeof(char), 1, f);
  for (i = 0; i < 4; i++) {
    for (j = 0; j < 256; j++) {
      int k = (i*256 + j)/4;
      int l = 255 - k;
      fwrite(&k, sizeof(char), 1, f);
      fwrite(&z, sizeof(char), 1, f);
      fwrite(&l, sizeof(char), 1, f);
    }
  }
  fclose(f);  
  f = fopen("mpeg_sc/test1.ppm", "wb");
  fprintf(f, "P6\n#test1.ppm -- ujk, 3-8-00\n32 32\n255"); 
  i = 10;
  fwrite(&i, sizeof(char), 1, f);
  for (i = 0; i < 4; i++) {
    for (j = 0; j < 256; j++) {
      int k = (i*256 + j)/4;
      int l = 255 - k;
      fwrite(&k, sizeof(char), 1, f);
      fwrite(&z, sizeof(char), 1, f);
      fwrite(&l, sizeof(char), 1, f);
    }
  }
  fclose(f);  


  f = fopen("mpeg_sc/bar0.ppm", "wb");
  fprintf(f, "P6\n#bar0.ppm -- rixner, 3-10-00\n48 48\n255"); 
  i = 10;
  fwrite(&i, sizeof(char), 1, f);
  for (row = 0; row < 48; row++) {
    for (col = 0; col < 48; col++) {
      int white = 255;