vid_main.c

Go to the documentation of this file.

/************************************************************************
 *
 *  vid_main.c, main module of tmn (TMN encoder).
 *  tmn is an H.263 encoder somewhat based on the Test Model Near-term
 *  (TMN5) in the ITU-T LBC Experts Group.
 *
 *  Copyright (C) 1995, 1996  Telenor R&D, Norway
 *        Karl Olav Lillevold <Karl.Lillevold@nta.no>
 *  
 *  Contacts: 
 *  Karl Olav Lillevold               <Karl.Lillevold@nta.no>, or
 *  Robert Danielsen                  <Robert.Danielsen@nta.no>
 *
 *  Telenor Research and Development  http://www.nta.no/brukere/DVC/
 *  P.O.Box 83                        tel.:   +47 63 84 84 00
 *  N-2007 Kjeller, Norway            fax.:   +47 63 81 00 76
 *  
 ************************************************************************/

/*
 * Disclaimer of Warranty
 *
 * These software programs are available to the user without any
 * license fee or royalty on an "as is" basis.  Telenor Research and
 * Development disclaims any and all warranties, whether express,
 * implied, or statuary, including any implied warranties or
 * merchantability or of fitness for a particular purpose.  In no
 * event shall the copyright-holder be liable for any incidental,
 * punitive, or consequential damages of any kind whatsoever arising
 * from the use of these programs.
 *
 * This disclaimer of warranty extends to the user of these programs
 * and user's customers, employees, agents, transferees, successors,
 * and assigns.
 *
 * Telenor Research and Development does not represent or warrant that
 * the programs furnished hereunder are free of infringement of any
 * third-party patents.
 *
 * Commercial implementations of H.263, including shareware, are
 * subject to royalty fees to patent holders.  Many of these patents
 * are general enough such that they are unavoidable regardless of
 * implementation design.
 * */


#include "vid_sim.h"
#include "video_codec.h"

extern video_codec *VidSt;

FILE *streamfile;

/**********************************************************************
 *
 *      Name:        NextTwoPB
 *      Description:    Decides whether or not to code the next
 *                      two images as PB
 *      Speed:          This is not a very smart solution considering
 *                      the encoding speed, since motion vectors
 *                      have to be calculation several times. It 
 *                      can be done together with the normal
 *                      motion vector search, or a tree search 
 *                      instead of a full search can be used.
 *      
 *      Input:          pointers to previous image, potential B- 
 *                      and P-image, frame distances
 *      Returns:        1 for yes, 0 otherwise
 *      Side effects:
 *
 *      Date: 950824    Author: Karl.Lillevold@nta.no
 *
 ***********************************************************************/

int NextTwoPB(PictImage *next2, PictImage *next1, PictImage *prev, 
              int bskip, int pskip, int seek_dist)
{
  int adv_is_on = 0, mof_is_on = 0, lv_is_on = 0;
  int psad1, psad2, bsad, psad;
  MotionVector *MV[6][MBR+1][MBC+2];
  MotionVector *mvp, *mvbf, *mvbb;
  int x,y;
  int i,j,k,tmp;

  /* Temporarily disable some options to simplify motion estimation */
  if ((VidSt->advanced)) {
    (VidSt->advanced) = OFF;
    adv_is_on = ON;
  }
  if ((VidSt->mv_outside_frame)) {
    (VidSt->mv_outside_frame) = OFF;
    mof_is_on = ON;
  }
  if ((VidSt->long_vectors)) {
    (VidSt->long_vectors) = OFF;
    lv_is_on = ON;
  }

  for (j = 1; j <= ((VidSt->lines)>>4); j++) 
    for (i = 1; i <= ((VidSt->pels)>>4); i++) 
      for (k = 0; k < 3; k++) {
        MV[k][j][i] = (MotionVector *)calloc(1,sizeof(MotionVector));
        /* calloc to avoid Checker warnings about reading of
           unitizalized memory in the memcpy's below */
      }

  mvbf = (MotionVector *)malloc(sizeof(MotionVector));
  mvbb = (MotionVector *)malloc(sizeof(MotionVector));

  psad = 0;
  psad1 = 0;
  psad2 = 0;
  bsad = 0;

  /* Integer motion estimation */
  for ( j = 1; j < (VidSt->lines)/MB_SIZE - 1; j++) {
    for ( i = 1; i < (VidSt->pels)/MB_SIZE - 1 ; i++) {
      x = i*MB_SIZE;
      y = j*MB_SIZE;

      /* picture order: prev -> next1 -> next2 */
      /* next1 and next2 can be coded as PB or PP */
      /* prev is the previous encoded picture */

      /* computes vectors (prev <- next2) */
      MotionEstimation(next2->lum,prev->lum,x,y,0,0,seek_dist,MV,&tmp);
      if (MV[0][j+1][i+1]->x == 0 && MV[0][j+1][i+1]->y == 0)
        MV[0][j+1][i+1]->min_error += PREF_NULL_VEC;
      /* not necessary to prefer zero vector here */
      memcpy(MV[2][j+1][i+1],MV[0][j+1][i+1],sizeof(MotionVector));

      /* computes sad(prev <- next1) */
      MotionEstimation(next1->lum,prev->lum,x,y,0,0,seek_dist,MV,&tmp);
      if (MV[0][j+1][i+1]->x == 0 && MV[0][j+1][i+1]->y == 0)
        MV[0][j+1][i+1]->min_error += PREF_NULL_VEC;
      memcpy(MV[1][j+1][i+1],MV[0][j+1][i+1],sizeof(MotionVector));

      /* computes vectors for (next1 <- next2) */
      MotionEstimation(next2->lum,next1->lum,x,y,0,0,seek_dist,MV,&tmp);
      if (MV[0][j+1][i+1]->x == 0 && MV[0][j+1][i+1]->y == 0)
        MV[0][j+1][i+1]->min_error += PREF_NULL_VEC;

      /* scales vectors for (prev <- next2 ) */
      mvp = MV[2][j+1][i+1];
      mvbf->x =   bskip * mvp->x / (bskip + pskip);
      mvbb->x = - pskip * mvp->x / (bskip + pskip);
      mvbf->y =   bskip * mvp->y / (bskip + pskip);
      mvbb->y = - pskip * mvp->y / (bskip + pskip);

      psad1 += MV[0][j+1][i+1]->min_error;
      psad2 += MV[1][j+1][i+1]->min_error;
      psad +=  mvp->min_error;

      /* computes sad(prev <- next1 -> next2) */
      bsad += SAD_MB_Bidir(next1->lum + x + y*(VidSt->pels),
           next2->lum + x + mvbb->x + (y + mvbb->y)*(VidSt->pels),
           prev->lum + x + mvbf->x + (y + mvbf->y)*(VidSt->pels),
           (VidSt->pels), INT_MAX);
    }
  }

  for (j = 1; j <= ((VidSt->lines)>>4); j++) 
    for (i = 1; i <= ((VidSt->pels)>>4); i++) 
      for (k = 0; k < 3; k++) 
        free(MV[k][j][i]);
  free(mvbf);
  free(mvbb);

  /* restore advanced parameters */
  (VidSt->advanced) = adv_is_on;
  (VidSt->mv_outside_frame) = mof_is_on;
  (VidSt->long_vectors) = lv_is_on;

  /* do the decision */
  if (bsad < (psad1+psad2)/2)
    fprintf(stdout,"Chose PB - bsad %d, psad %d\n", 
            bsad, (psad1+psad2)/2);
  else
    fprintf(stdout,"Chose PP  - bsad %d, psad %d\n", 
            bsad, (psad1+psad2)/2);

  if (bsad < (psad1 + psad2)/2)
    return 1;
  else 
    return 0;
}


/**********************************************************************
 *
 *      Name:        PrintResult
 *      Description:    add bits and prints results
 *      
 *      Input:        Bits struct
 *        
 *      Returns:        
 *      Side effects:   
 *
 *      Date: 940116    Author: Karl.Lillevold@nta.no
 *
 ***********************************************************************/


void PrintResult(Bits *bits,int num_units, int num)
{
  fprintf(stdout,"# intra   : %d\n", bits->no_intra/num_units);
  fprintf(stdout,"# inter   : %d\n", bits->no_inter/num_units);
  fprintf(stdout,"# inter4v : %d\n", bits->no_inter4v/num_units);
  fprintf(stdout,"--------------\n");
  fprintf(stdout,"Coeff_Y: %d\n", bits->Y/num);
  fprintf(stdout,"Coeff_C: %d\n", bits->C/num);
  fprintf(stdout,"Vectors: %d\n", bits->vec/num);
  fprintf(stdout,"CBPY   : %d\n", bits->CBPY/num);
  fprintf(stdout,"MCBPC  : %d\n", bits->CBPCM/num);
  fprintf(stdout,"MODB   : %d\n", bits->MODB/num);
  fprintf(stdout,"CBPB   : %d\n", bits->CBPB/num);
  fprintf(stdout,"COD    : %d\n", bits->COD/num);
  fprintf(stdout,"DQUANT : %d\n", bits->DQUANT/num);
  fprintf(stdout,"header : %d\n", bits->header/num);
  fprintf(stdout,"==============\n");
  fprintf(stdout,"Total  : %d\n", bits->total/num);
  fprintf(stdout,"\n");
  return;
}

void PrintSNR(Results *res, int num)
{
  FILE *fp = fopen("snr.dat","a");
  assert(fp!=NULL);
  fprintf(fp,"%.2f %.2f %.2f\n",res->SNR_l/num,res->SNR_Cb/num,res->SNR_Cr/num);
  fclose(fp);
  fprintf(stdout,"SNR_Y  : %.2f\n", res->SNR_l/num);
  fprintf(stdout,"SNR_Cb : %.2f\n", res->SNR_Cb/num);
  fprintf(stdout,"SNR_Cr : %.2f\n", res->SNR_Cr/num);
  fprintf(stdout,"--------------\n");

  return;
}

---