Subversion Repositories mpeg2fpga

/* #define DEBUG */

/* subspic.c, Frame buffer substitution routines */

/* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */

/*

 * Disclaimer of Warranty

 *

 * These software programs are available to the user without any license fee or

 * royalty on an "as is" basis.  The MPEG Software Simulation Group 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.

 *

 * The MPEG Software Simulation Group does not represent or warrant that the

 * programs furnished hereunder are free of infringement of any third-party

 * patents.

 *

 * Commercial implementations of MPEG-1 and MPEG-2 video, 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 <stdio.h>

#include <stdlib.h>

#include <fcntl.h>

#include "config.h"

#include "global.h"

/* private prototypes*/

static void Read_Frame _ANSI_ARGS_((char *filename,

  unsigned char *frame_buffer[], int framenum));

static void Copy_Frame _ANSI_ARGS_((unsigned char *src, unsigned char *dst,

  int width, int height, int parity, int incr));

static int Read_Components _ANSI_ARGS_ ((char *filename,

  unsigned char *frame[3], int framenum));

static int Read_Component _ANSI_ARGS_ ((char *fname, unsigned char *frame,

  int width, int height));

static int Extract_Components _ANSI_ARGS_ ((char *filename,

  unsigned char *frame[3], int framenum));

/* substitute frame buffer routine */

void Substitute_Frame_Buffer (bitstream_framenum, sequence_framenum)

int bitstream_framenum;

int sequence_framenum;

{

  /* static tracking variables */

  static int previous_temporal_reference;

  static int previous_bitstream_framenum;

  static int previous_anchor_temporal_reference;

  static int previous_anchor_bitstream_framenum;

  static int previous_picture_coding_type;

  static int bgate;

  /* local temporary variables */

  int substitute_display_framenum;

#ifdef DEBUG

  printf("SUB: seq fn(%d) bitfn(%d) tempref(%d) picstr(%d) type(%d)\n",

    sequence_framenum, bitstream_framenum, temporal_reference,

    picture_structure, picture_coding_type);

#endif

  /* we don't substitute at the first picture of a sequence */

  if((sequence_framenum!=0)||(Second_Field))

  {

    /* only at the start of the frame */

    if ((picture_structure==FRAME_PICTURE)||(!Second_Field))

    {

      if(picture_coding_type==P_TYPE)

      {

        /* the most recently decoded reference frame needs substituting */

        substitute_display_framenum = bitstream_framenum - 1;

        Read_Frame(Substitute_Picture_Filename, forward_reference_frame,

          substitute_display_framenum);

      }

      /* only the first B frame in a consequitve set of B pictures

         loads a substitute backward_reference_frame since all subsequent

         B frames predict from the same reference pictures */

      else if((picture_coding_type==B_TYPE)&&(bgate!=1))

      {

        substitute_display_framenum =

          (previous_temporal_reference - temporal_reference)

            + bitstream_framenum - 1;

        Read_Frame(Substitute_Picture_Filename, backward_reference_frame,

          substitute_display_framenum);

      }

    } /* P fields can predict from the two most recently decoded fields, even

         from the first field of the same frame being decoded */

    else if(Second_Field && (picture_coding_type==P_TYPE))

    {

      /* our favourite case: the IP field picture pair */

      if((previous_picture_coding_type==I_TYPE)&&(picture_coding_type==P_TYPE))

      {

        substitute_display_framenum = bitstream_framenum;

      }

      else /* our more generic P field picture pair */

      {

        substitute_display_framenum =

          (temporal_reference - previous_anchor_temporal_reference)

            + bitstream_framenum - 1;

      }

      Read_Frame(Substitute_Picture_Filename, current_frame, substitute_display_framenum);

    }

#ifdef DEBUG

    else if((picture_coding_type!=B_TYPE)||(picture_coding_type!=D_TYPE))

    {

      printf("NO SUBS FOR THIS PICTURE\n");

    }

#endif

  }

  /* set b gate so we don't redundantly load next time around */

  if(picture_coding_type==B_TYPE)

    bgate = 1;

  else

    bgate = 0;

  /* update general tracking variables */

  if((picture_structure==FRAME_PICTURE)||(!Second_Field))

  {

    previous_temporal_reference  = temporal_reference;

    previous_bitstream_framenum  = bitstream_framenum;

  }

  /* update reference frame tracking variables */

  if((picture_coding_type!=B_TYPE) &&

    ((picture_structure==FRAME_PICTURE)||Second_Field))

  {

    previous_anchor_temporal_reference  = temporal_reference;

    previous_anchor_bitstream_framenum  = bitstream_framenum;

  }

  previous_picture_coding_type = picture_coding_type;

}

/* Note: fields are only read to serve as the same-frame reference for

   a second field */

static void Read_Frame(fname,frame,framenum)

char *fname;

unsigned char *frame[];

int framenum;

{

  int parity;

  int rerr = 0;

  int field_mode;

  if(framenum<0)

    printf("ERROR: framenum (%d) is less than zero\n", framenum);

  if(Big_Picture_Flag)

    rerr = Extract_Components(fname, substitute_frame, framenum);

  else

    rerr = Read_Components(fname, substitute_frame, framenum);

  if(rerr!=0)

  {

    printf("was unable to substitute frame\n");

  }

  /* now copy to the appropriate buffer */

  /* first field (which we are attempting to substitute) must be

     of opposite field parity to the current one */

  if((Second_Field)&&(picture_coding_type==P_TYPE))

  {

    parity      = (picture_structure==TOP_FIELD ? 1:0);

    field_mode  = (picture_structure==FRAME_PICTURE ? 0:1);

  }

  else

  {

    /* Like frame structued pictures, B pictures only substitute an entire frame

       since both fields always predict from the same frame (with respect

       to forward/backwards directions) */

    parity = 0;

    field_mode = 0;

  }

  Copy_Frame(substitute_frame[0], frame[0], Coded_Picture_Width,

    Coded_Picture_Height, parity, field_mode);

  Copy_Frame(substitute_frame[1], frame[1], Chroma_Width, Chroma_Height,

    parity, field_mode);

  Copy_Frame(substitute_frame[2], frame[2], Chroma_Width, Chroma_Height,

    parity, field_mode);

#ifdef VERBOSE

  if(Verbose_Flag > NO_LAYER)

    printf("substituted %s %d\n",

      (field_mode ? (parity?"bottom field":"bottom field"):"frame"), framenum);

#endif

}

static int Read_Components(filename, frame, framenum)

char *filename;

unsigned char *frame[3];

int framenum;

{

  int err = 0;

  char outname[FILENAME_LENGTH];

  char name[FILENAME_LENGTH];

  sprintf(outname,filename,framenum);

  sprintf(name,"%s.Y",outname);

  err += Read_Component(name, frame[0], Coded_Picture_Width,

    Coded_Picture_Height);

  sprintf(name,"%s.U",outname);

  err += Read_Component(name, frame[1], Chroma_Width, Chroma_Height);

  sprintf(name,"%s.V",outname);

  err += Read_Component(name, frame[2], Chroma_Width, Chroma_Height);

  return(err);

}

static int Read_Component(Filename, Frame, Width, Height)

char *Filename;

unsigned char *Frame;

int Width;

int Height;

{

  int Size;

  int Bytes_Read;

  int Infile;

  Size = Width*Height;

#ifdef DEBUG

  printf("SUBS: reading %s\n", Filename);

#endif

  if(!(Infile=open(Filename,O_RDONLY|O_BINARY))<0)

  {

    printf("ERROR: unable to open reference filename (%s)\n", Filename);

        return(-1);

  }

  Bytes_Read = read(Infile, Frame, Size);

  if(Bytes_Read!=Size)

  {

    printf("was able to read only %d bytes of %d of file %s\n",

      Bytes_Read, Size, Filename);

  }

  close(Infile);

  return(0);

}

/* optimization: do not open the big file each time. Open once at start

   of decoder, and close at the very last frame */

/* Note: "big" files were used in E-mail exchanges almost exclusively by the

   MPEG Committee's syntax validation and conformance ad-hoc groups from

   the year 1993 until 1995 */

static int Extract_Components(filename, frame, framenum)

char *filename;

unsigned char *frame[3];

int framenum;

{

/*  int err = 0; */

  FILE *fd;

  int line;

  int size, offset;

  if (!(fd = fopen(filename,"rb")))

  {

    sprintf(Error_Text,"Couldn't open %s\n",filename);

    return(-1);

  }

  /* compute size of each frame (in bytes) */

  size = (Coded_Picture_Width*Coded_Picture_Height);

  if(chroma_format==CHROMA444)

    size = (size * 3);

  else if(chroma_format==CHROMA422)

    size = (size * 2);

  else if(chroma_format==CHROMA420)

    size = ((size*3)>>1);

  else

    printf("ERROR: chroma_format (%d) not recognized\n", chroma_format);

  /* compute distance into "big" file */

  offset = size*framenum;

#ifdef DEBUG

  printf("EXTRACTING: frame(%d) offset(%d), size (%d) from %s\n",

    framenum, offset, size, filename);

#endif

  /* seek to location in big file where desired frame begins */

  /* note: this offset cannot exceed a few billion bytes due to the */

  /*       obvious limitations of 32-bit integers */

  fseek(fd, offset, 0);

  /* Y  */

  for (line=0; line<Coded_Picture_Height; line++)

  {

    fread(frame[0]+(line*Coded_Picture_Width),1,Coded_Picture_Width,fd);

  }

  /* Cb */

  for (line=0; line<Chroma_Height; line++)

  {

    fread(frame[1]+(line*Chroma_Width),1,Chroma_Width,fd);

  }

  /* Cr */

  for (line=0; line<Chroma_Height; line++)

  {

    fread(frame[2]+(line*Chroma_Width),1,Chroma_Width,fd);

  }

  fclose(fd);

  return(0);

}

static void Copy_Frame(src, dst, width, height, parity, field_mode)

unsigned char *src;

unsigned char *dst;

int width;

int height;

int parity;        /* field parity (top or bottom) to overwrite */

int field_mode;    /* 0 = frame, 1 = field                      */

{

  int row, col;

  int s, d;

  int incr;

  s = d = 0;

#ifdef DEBUG

  printf("COPYING (w=%d, h=%d, parity=%d, field_mode=%d)\n",

    width,height,parity,field_mode);

#endif /* DEBUG */

  if(field_mode)

  {

    incr = 2;

    if(parity==0)

      s += width;

  }

  else

  {

    incr = 1;

  }

  for(row=0; row<height; row+=incr)

  {

    for(col=0; col<width; col++)

    {

      dst[d+col] = src[s+col];

    }

    d += (width*incr);

    s += (width*incr);

  }

}