vid_wrapper.c

Go to the documentation of this file.

/*
 *
 * Brendan Dowling, UCLA IPL, 8/28/96
 */

#include "standard.h"
#include <unistd.h>
#include "video_codec.h"
#include "input.h"
#include "vid_wrapper.h"

#define LOW_WATER_MARK 250
#define STRLEN 256
#define CHUNKSIZE 500

video_codec *VidSt;

static int filelen(char *fn)
/*
 * Returns the length of a file.
 */
{
  int f, l;
  f = open(fn);
  if (f == -1)
    l = 0;
  else {
    lseek(f, 0, 2);
    //Rajivl = tell(f);
    close(f);
  }
  return (l);
}



static char *stripext(char *fn)
/*
 * Strips the file extension (.*) from the end of a filename.
 * Won't nullify the string (which is good).
 */
{
  static char r[256];
  int i, ok;


  strcpy(r, fn);
  i = strlen(r) - 1;

  while (i >= 0) {
    if ((r[i]=='.') && (i != 0)) {
      r[i]='\0';
      break;
    }
    else
      i--;
  }
  return (r);
}


static void config_vc(video_codec *v)
/* 
 * Set default configuration options for video coder.
 */
{
  char s[256], sx[256];
  int okf;
  
  strcpy(v->input_file, DEF_VID_INPUT_FILE);

  sprintf(sx, "%s.263.sent", v->label);
  strcpy(v->streamname, sx); 

  sprintf(sx, "%s.263.received", v->label);
  strcpy(v->output_file, sx);

  v->start = 0;  /* start frame */

  v->targetrate = DEF_TARGET_BITRATE;
}

void set_frames(video_codec *v)
/*
 * set the number of frames to process
 */
{
  int numf;

  numf = (filelen(v->input_file) / ((v->pels * v->lines) * 1.5)) - 1; 
  v->end = numf;
}

int FindFrameSkip(int last)
/*
 * Used to advance frame counter to code a frame.
 */
{
  float seconds_elapsed = (float) (get_clock()-(VidSt->start_time)) / 1000;

  int ideal_frame = (int) (seconds_elapsed * (VidSt->ref_frame_rate));
  return (ideal_frame - last);
}


video_codec *new_video_codec(char *name)
     /*
      * This function shall set up a new video codec and return a pointer to it.  
      * It will do all the initialization stuff that would have been done
      * in the main() procedure of TMN.
      *
      * Note: Ignoring OFFLINE_RATE_CONTROL stuff while I make changes.  This will
      * probably break OFFLINE_RATE_CONTROL, but that doesn't matter because this
      * system is going to be used in an online matter only anyways.  
      */
{
  video_codec *v;
  
  v = malloc(sizeof(video_codec));
  if (v != NULL) {
    
    memset(v, 0, sizeof(video_codec));

    VidSt = v;

    strcpy(v->label, name);
    v->done = 0;


    /* 
     * Initialization stuff from vid_main.c 
     */

    v->prev_image = NULL;
    v->curr_image = NULL;
    v->curr_recon = NULL;
    v->prev_recon = NULL;
    v->B_recon = NULL;
    v->B_image = NULL;
    v->pic = (Pict *)malloc(sizeof(Pict));
    v->first_loop_finished=0;
    v->PPFlag = 0;
    v->pdist = 0;
    v->bdist = 0;
    v->bits = (Bits *)malloc(sizeof(Bits));
    v->total_bits = (Bits *)malloc(sizeof(Bits));
    v->intra_bits = (Bits *)malloc(sizeof(Bits));
    v->res = (Results *)malloc(sizeof(Results));
    v->total_res = (Results *)malloc(sizeof(Results));
    v->b_res = (Results *)malloc(sizeof(Results));
    /* v->seqfilename = (char *)malloc(sizeof(char)*100); */
    v->streamname = (char *)malloc(sizeof(char)*100);
    v->outputfile =  (char *)malloc(sizeof(char)*100);
    v->diff_filename=DEF_DIFFILENAME;
    v->tracefile =  (char *)malloc(sizeof(char)*100);
    

    fprintf(stdout, "\nTMN (H.263) coder version 2.0, ");
    fprintf(stdout, "Copyright (C) 1995, 1996 Telenor R&D, Norway\n");
    fprintf(stdout, "Heavy modification by Brendan Dowling based upon work by Feng Chen\n");
    
    v->headerlength = DEF_HEADERLENGTH;
    
#ifndef FASTIDCT
    init_idctref();
#endif
    
    /* Default variable values */
    v->advanced = DEF_ADV_MODE;
    v->syntax_arith_coding = DEF_SAC_MODE;
    v->pic->unrestricted_mv_mode = DEF_UMV_MODE;
    v->mv_outside_frame = DEF_UMV_MODE || DEF_ADV_MODE;
    v->long_vectors = DEF_UMV_MODE;
    v->pb_frames = DEF_PBF_MODE;
    
    v->QP = DEF_INTER_QUANT;
    v->QPI = DEF_INTRA_QUANT;
    v->pic->BQUANT = DEF_BQUANT; 
    v->pic->source_format = DEF_CODING_FORMAT;
    
    v->ref_frame_rate = (float)DEF_REF_FRAME_RATE;
    v->chosen_frameskip = DEF_FRAMESKIP + 1;
    v->orig_frameskip = DEF_ORIG_SKIP + 1;

    v->pic->target_frame_rate = (float)DEF_TARGET_FRAME_RATE;
    
    /* v->seqfilename[0] = '\0'; */
    v->seqfilename = v->input_file;
    /*strcpy(v->streamname, DEF_STREAMNAME);*/
    strcpy(v->outputfile, DEF_OUTFILENAME);
    
    v->writediff = DEF_WRITE_DIFF;
    v->trace = DEF_WRITE_TRACE;
    v->write_repeated = DEF_WRITE_REPEATED;
    v->pic->seek_dist = DEF_SEEK_DIST;
    v->pic->use_gobsync = DEF_INSERT_SYNC;
    v->start = DEF_START_FRAME;
    v->end = DEF_STOP_FRAME;
    
    v->targetrate = 0; 
    /* default is variable bit rate (fixed quantizer) will be used */
    
    v->frames = 0;
    v->pframes = 0;
    v->bframes = 0;
    v->total_frames_passed = 0;
    v->pic->PB = 0;
    v->wcopies = v->icopies = 1;
    
    v->pic->TR = 0;
    v->pic->QP_mean = (float)0.0;
   

    switch (v->pic->source_format) {
    case (SF_SQCIF):
      fprintf(stdout, "Encoding format: SQCIF (128x96)\n");
      v->pels = 128;
      v->lines = 96;
      break;
    case (SF_QCIF):
      fprintf(stdout, "Encoding format: QCIF (176x144)\n");
      v->pels = 176;
      v->lines = 144;
      break;
    case (SF_CIF):
      fprintf(stdout, "Encoding format: CIF (352x288)\n");
      v->pels = 352;
      v->lines = 288;
      break;
    case (SF_4CIF):
      fprintf(stdout, "Encoding format: 4CIF (704x576)\n");
      v->pels = 704;
      v->lines = 576;
      break;
    case (SF_16CIF):
      fprintf(stdout, "Encoding format: 16CIF (1408x1152)\n");
      v->pels = 1408;
      v->lines = 1152;
      break;
    default:
      fprintf(stderr,"Illegal coding format\n");
      exit(-1);
    }
    v->cpels = v->pels/2;

    /*
     * Get options from user, since there is no command line.
     */
    config_vc(v);

    /* 
     * Make it so that first call to code_video will make initial frame.
     */
    v->first = 1;

    v->tmndecode = 0;
    v->no_coding = 0;
  }
  return (v);
}


void code_video(video_codec *v)
/*
 * Main video coding function.  Called a lot of times.
 *
 */
{
  int i, ok;
  FILE *cleared;
  FILE *inputfile;

  VidSt = v;

  /* 
   * first check if user decided to use a precoded video file
   */
   
  if (v->no_coding) {
    if (al_buffer_level(v->output) < LOW_WATER_MARK) {
      /* open the file for reading */
      if (v->input_file==NULL) 
        error("code_video","Input video not available");
      inputfile = fopen (v->input_file, "r");
      if (inputfile == NULL) {
        error("code_video","Unable to open input file\n");
      }
      fseek(inputfile,v->bytecnt,0);
      for (i=0;i<CHUNKSIZE;i++) {
        al_send_byte(v->output,fgetc(inputfile));
      }
      v->bytecnt += CHUNKSIZE;
      fclose(inputfile);
    }
  }

  /* 
   * Stuff from vid_main.c.  Will need to be modified a lot.  
   */
  
  else if (v->first) {
    /* 
     * the rest of the init stuff
     */

    if (v->seqfilename[0] == '\0') {
      fprintf(stderr,"Required input parameter missing\n");
      exit(-1);
    }
    
    /*
     * Rate control variables 
     */
    v->pic->bit_rate = v->targetrate;
    v->pic->src_frame_rate = (int)(v->ref_frame_rate / v->orig_frameskip);
    v->DelayBetweenFramesInSeconds = (float) 1.0/(float)v->pic->src_frame_rate;
    InitializeRateControl();


    if (v->QP == 0 || v->QPI == 0) {
      fprintf(stderr,"Warning:");
      fprintf(stderr,
              "QP is zero. Bitstream will not be correctly decodable\n");
    }
    
    if (v->ref_frame_rate != 25.0 && v->ref_frame_rate != 30.0) {
      fprintf(stderr,"Warning: Reference frame rate should be 25 or 30 fps\n");
    }
    
    v->frame_rate = v->ref_frame_rate / (float)(v->orig_frameskip * v->chosen_frameskip);

    if (v->pic->bit_rate == 0)
      fprintf(stdout,"Encoding frame rate  : %.2f\n", v->frame_rate);
    else
      fprintf(stdout,"Encoding frame rate  : variable\n");

    fprintf(stdout,"Reference frame rate : %.2f\n", v->ref_frame_rate);
    fprintf(stdout,"Orig. seq. frame rate: %.2f\n\n", 
            v->ref_frame_rate / (float)v->orig_frameskip);
    
    /* Open stream for writing */
    v->streamfile = fopen (v->streamname, "wb");
    if (v->streamfile == NULL) {
      fprintf(stderr, "Unable to open streamfile\n");
      exit(-1);
    }
    
    /* 
     * Initialize bitcounters 
     */
    initbits (v);
    
    if (v->trace) {
      strcpy(v->tracefile, "trace.intra");
      /* Open trace-file for writing */
      if ((v->tf = fopen(v->tracefile,"w")) == NULL) {
        fprintf(stderr,"Unable to open tracefile (intra)\n");
        exit(-1);
      }
    }

    /* 
     * Clear output files 
     */
    if ((cleared = fopen(v->outputfile,"wb")) == NULL) {
      fprintf(stderr,"Couldn't open outputfile: %s\n",v->outputfile);
      exit(-1);
    }
    else
      fclose(cleared);
    if (v->writediff) {
      if ((cleared = fopen(v->diff_filename,"wb")) == NULL) {
        fprintf(stderr,"Couldn't open diff-file: %s\n",v->diff_filename);
        exit(-1);
      }
      else
        fclose(cleared);
    }
    
    /* 
     * New initialization stuff
     */
    v->start_time = get_clock();
    v->last_frame = 0;
    v->simbuffer = 0;

    /* 
     * First (Intra) image 
     */

    v->image = ReadImage(v->seqfilename, v->start, v->headerlength);
    fprintf(stdout,"Coding...\n");
    v->curr_image = FillImage(v->image);
    v->pic->picture_coding_type = PCT_INTRA;
    v->pic->QUANT = v->QPI;
    
    v->curr_recon = CodeOneIntra(v->curr_image, v->QPI, v->bits, v->pic);
    
    if (v->arith_used) {
      v->bits->header += encoder_flush();
      v->arith_used = 0;
    }
    v->bits->header += alignbits (); /* pictures shall be byte aligned */
    
    fprintf(stdout,"Finished INTRA\n");
    
    ComputeSNR(v->curr_image, v->curr_recon, v->res, v->writediff);
    AddBitsPicture(v->bits);
    PrintSNR(v->res, 1);
    PrintResult(v->bits, 1, 1);
    memcpy(v->intra_bits,v->bits,sizeof(Bits));
    ZeroBits(v->total_bits);
    ZeroRes(v->total_res);
    ZeroRes(v->b_res);
    
    if (v->trace) {
      strcpy(v->tracefile, "trace");
      fclose(v->tf);
      /* Open trace-file for writing */
      if ((v->tf = fopen(v->tracefile,"w")) == NULL) {
        fprintf(stderr,"Unable to open tracefile (non-intra)\n");
        exit(-1);
      }
    }

    /*
     * Set up stuff for next frame
     */
    
    v->pic->picture_coding_type = PCT_INTER;
    v->pic->QUANT = v->QP;
    v->bdist = v->chosen_frameskip;
    
    /*
     * Always encode the first frame after intra as P frame.
     * This is not necessary, but something we chose to make
     * the adaptive PB frames calculations a bit simpler 
     */
    if (v->pb_frames) {
      v->pic->PB = 0;
      v->pdist = 2*v->chosen_frameskip - v->bdist;
    }
    
    if (v->write_repeated) 
      v->icopies = v->chosen_frameskip;
    for (i = 0; i < v->icopies; i++)
      WriteImage(v->curr_recon,v->outputfile); /* write wcopies frames to disk */
    

    /*
     * Next time, code as usual.  
     */
    v->first = 0;
    v->last_frame = v->start;
    v->frame_no = v->start;
  } 
  else {
    /*
     * Code some image other than the first image.
     */
    
    ok = 0;

    if (v->frame_no <= v->end) {
      
      if (al_buffer_level(v->output) < LOW_WATER_MARK) 
        ok = 1;
      
      if (ok) {
        v->frameskip = FindFrameSkip(v->last_frame);
        v->frame_no += v->frameskip;
      }
    }
    if ((ok) && (v->frame_no <= v->end) &&(v->frameskip)) {


      v->prev_image = v->curr_image;
      v->prev_recon = v->curr_recon;
      
      /* Set QP to pic->QUANT from previous encoded picture */
      
      v->QP = v->pic->QUANT;
      
      if (!v->PPFlag) {
        if (v->pic->PB) { 
          v->bdist = v->frameskip;
          v->pdist = 2*v->frameskip - v->bdist;
          v->pic->TRB = v->bdist * v->orig_frameskip;
          if (v->pic->TRB > 8)
            fprintf(stdout,"distance too large for B-frame\n");
          /* Read the frame to be coded as B */
          v->image = ReadImage(v->seqfilename,v->frame_no,v->headerlength);
          v->B_image = FillImage(v->image);
          v->first_loop_finished = 1;
          if (v->frame_no + v->pdist <= v->end) {
            v->image = ReadImage(v->seqfilename,v->frame_no + v->pdist,v->headerlength);
          }
          else {
            v->pic->PB = 0; /* end of sequence, encode as P */
            v->image =  ReadImage(v->seqfilename,v->frame_no,v->headerlength);
          }
        }
        else {
          v->image = ReadImage(v->seqfilename,v->frame_no,v->headerlength);
        }
        v->curr_image = FillImage(v->image);
        
        if (v->pic->PB) {
          if (v->pic->TRB > 8 || !NextTwoPB(v->curr_image, v->B_image, v->prev_image, 
                                            v->bdist, v->pdist, v->pic->seek_dist)) {
            /* curr_image and B_image were not suitable to be coded
               as a PB-frame - encoding as two P-frames instead */
            v->pic->PB = 0;
            
            FreeImage(v->curr_image);
            
            v->frameskip = v->bdist;
            
            v->curr_image = v->B_image;
            v->PPFlag = 1;
          }
          else {
            v->frame_no += v->pdist;
          }
        }
      }
      else {
        /* PPFlag is set when the second of the two P-frames 
           is due to be coded */
        
        v->image =  ReadImage(v->seqfilename,v->frame_no,v->headerlength);
        v->curr_image = FillImage(v->image);
        
        v->pic->PB = 0;
        v->PPFlag = 0;
      }
      
      /* Temporal Reference is the distance between encoded frames compared
         the reference picture rate which is 25.0 or 30 fps */
      v->pic->TR += (( (v->frameskip+(v->pic->PB?v->pdist:0)) *v->orig_frameskip) % 256); 
      if (v->frameskip+(v->pic->PB?v->pdist:0) > 256)
        fprintf(stdout,"Warning: frameskip > 256\n");
      
      
      v->frames += (v->pic->PB ? 2: 1);
      v->bframes += (v->pic->PB ? 1 : 0);
      v->pframes += 1;
      
      if (v->pic->PB) { /* Code two frames as a PB-frame */
        v->B_recon = InitImage(v->pels*v->lines);
        fprintf(stdout,"Coding PB frames %d and %d... ",
                v->frame_no - v->pdist, v->frame_no);
        fflush(stdout);
      }
      else { /* Code the next frame as a normal P-frame */
        fprintf(stdout,"Coding P frame %d... ", v->frame_no);
        fflush(stdout);
      }
      v->curr_recon = InitImage(v->pels*v->lines);
      
      
      CodeOneOrTwo(v->curr_image, v->B_image, v->prev_image, v->prev_recon, 
                   v->QP, (v->bdist+v->pdist)*v->orig_frameskip, v->bits, v->pic, 
                   v->B_recon, v->curr_recon);
      
      
      fprintf(stdout,"done\n");
      if (v->targetrate != 0)
        fprintf(stdout,"Inter QP: %d\n", v->QP);
      fflush(stdout);
      
      if (v->arith_used) {
        v->bits->header += encoder_flush();
        v->arith_used = 0;
      }
      
      v->bits->header += alignbits ();  /* pictures shall be byte aligned */
      AddBitsPicture(v->bits);
      AddBits(v->total_bits, v->bits);
      
      if (v->pic->bit_rate != 0 && v->pic->PB)
        v->CommBacklog -= (int) 
          ( v->DelayBetweenFramesInSeconds*v->pic->bit_rate ) * v->pdist;
      
      if (v->pic->bit_rate != 0) {
        UpdateRateControl(v->bits->total);
        
        v->CommBacklog += v->bits->total;
        v->frameskip = 1;
        v->CommBacklog -= (int) 
          (v->frameskip * v->DelayBetweenFramesInSeconds *v->pic->bit_rate);
        
        while ( (int)(v->DelayBetweenFramesInSeconds*v->pic->bit_rate) <= v->CommBacklog)
          {
            v->CommBacklog -= (int) ( v->DelayBetweenFramesInSeconds * v->pic->bit_rate );
            v->frameskip += 1;
          }
      }
      
      if (v->pic->PB) {
        if (v->write_repeated) 
          v->wcopies = v->pdist;
#if(0)
        for (i = 0; i <v-> wcopies; i++)
          WriteImage(v->B_recon,v->outputfile); /* write wcopies frames to disk */
#endif
        ComputeSNR(v->B_image, v->B_recon, v->res, v->writediff);
        fprintf(stdout,"Results for B-frame:\n");
        AddRes(v->b_res,v->res,v->pic);
        PrintSNR(v->res, 1);
        FreeImage(v->B_image);
        FreeImage(v->B_recon);
      }
      
      if (v->write_repeated) 
        v->wcopies = (v->pb_frames) ? v->bdist : v->frameskip;
#if(0)
      for (i = 0; i < v->wcopies; i++)
        WriteImage(v->curr_recon,v->outputfile); /* write wcopies frames to disk */
#endif 
      if (v->pb_frames)
        v->pic->PB = 1;
      
      ComputeSNR(v->curr_image, v->curr_recon, v->res, v->writediff); 
      fprintf(stdout,"Results for P-frame:\n");
      AddRes(v->total_res,v->res,v->pic);
      PrintSNR(v->res, 1);
      PrintResult(v->bits, 1, 1);
      FreeImage(v->prev_image);
      FreeImage(v->prev_recon);
      fflush(stdout);


      v->last_frame = v->frame_no;
    }
    /***** end of main loop from vid_main.c *****/
  }
}


void close_video_codec(video_codec *v)
{
  char s[STRLEN];
  int junk;

  VidSt = v;


  /* Closing files */
  fclose (v->streamfile);
  if (v->trace) {
    fclose(v->tf);
  }

  /* Print total results */
  v->total_frames_passed = v->frame_no - v->start;

  fprintf(stdout,"\n==== TOTAL ====\n");
  fprintf(stdout,"for %d images of %s\n", v->frames, v->seqfilename);

  if (v->frames != 0) {
    if (v->write_repeated) 
      fprintf(stdout,"Frames saved : %d predicted + %d intra\n",
              v->total_frames_passed,v->icopies);

    fprintf(stdout,"--------------\n");

    if (v->pb_frames && v->bframes != 0) {
      fprintf(stdout,"SNR for %d B-frames:\n",v->bframes);
      PrintSNR(v->b_res,v->bframes);
    }

    fprintf(stdout,"SNR for %d P-frames:\n",v->pframes);
    PrintSNR(v->total_res,v->pframes);

    PrintResult(v->total_bits, v->pframes, v->frames);

    if (v->targetrate != 0 || v->pic->bit_rate != 0) 
      fprintf(stdout,"Original seq time: %.2f sec\n", 
              v->total_frames_passed / v->ref_frame_rate);

    fprintf(stdout,"Mean quantizer   : %.2f\n", v->total_res->QP_mean/v->pframes);

#if(0)
    fprintf(stdout,"Total frames     : %3d\n", 
            v->total_frames_passed);
#endif

    fprintf(stdout,"Encoded frames   : %3d (%3d)\n", 
            v->frames + 1,
            v->frames);

    v->mean_frame_rate = v->frames  / (float)v->total_frames_passed * 
      v->ref_frame_rate / (float)v->orig_frameskip;

    fprintf(stdout,"Mean frame rate  : %.2f Hz\n", v->mean_frame_rate);

    if (v->targetrate != 0)
      fprintf(stdout,"Target bit rate  : %.2f kbit/sec\n", 
              v->targetrate/1000.0);

    fprintf(stdout,"Obtained bit rate: %.2f (%.2f) kbit/sec\n",
            (v->total_bits->total + v->intra_bits->total) / 
            ((v->total_frames_passed) / 
             v->ref_frame_rate * v->orig_frameskip)/1000.0,
            (v->total_bits->total / (float)v->frames) * v->mean_frame_rate/1000.0);

    fprintf(stdout,"============================================\n");

  }
#if(0)
  fprintf(stdout,"Total number of bits: %d (%d)\n",
          v->total_bits->total + v->intra_bits->total,
          (v->total_bits->total + v->intra_bits->total) / 8);
#endif

  /* if user wants to use tmndec to display the received video, do it */
  if (v->tmndecode) {
    printf("[%s] ready to use tmndec to display output video..\n",v->label);
    printf("Press return key when ready. . .\n");
    junk = getchar();
    printf("displaying...\n");
    sprintf(s,"tmndecode -o4 -q %s &",v->output_file);
    system(s);
    printf("Press return key when ready to resume. . .\n");
    junk = getchar();
  }

  /* Free memory */
  if (v->frames != 0) {
    FreeImage(v->curr_recon);
    FreeImage(v->curr_image);
  }
  free(v->streamname);
  free(v->outputfile);
  free(v->tracefile);
  free(v->bits);
  free(v->total_bits);
  free(v->intra_bits);
  free(v->res);
  free(v->total_res);
  free(v->b_res);
  free(v->pic);
  free(v);
}


void decode_video(video_codec *bob)
     /*
      * Read any data in and save it.  
      */
{
  FILE *outfile=NULL;
  
  byte b;

  if (al_indication(bob->input)) {

    outfile = fopen(bob->output_file, "a");

    if (outfile == NULL) {
      error("decode_video","can't open output file");
    }
  }

  while (al_indication(bob->input)) { 

    b = al_receive(bob->input);

    fputc(b, outfile);
  }

  if (outfile) {
    fclose(outfile);
  }
}

---