Subversion Repositories qaz_libs

//////////////////////////////////////////////////////////////////////

////                                                              ////

//// Copyright (C) 2015 Authors and OPENCORES.ORG                 ////

////                                                              ////

//// This source file may be used and distributed without         ////

//// restriction provided that this copyright statement is not    ////

//// removed from the file and that any derivative work contains  ////

//// the original copyright notice and the associated disclaimer. ////

////                                                              ////

//// This source file is free software; you can redistribute it   ////

//// and/or modify it under the terms of the GNU Lesser General   ////

//// Public License as published by the Free Software Foundation; ////

//// either version 2.1 of the License, or (at your option) any   ////

//// later version.                                               ////

////                                                              ////

//// This source is distributed in the hope that it will be       ////

//// useful, but WITHOUT ANY WARRANTY; without even the implied   ////

//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR      ////

//// PURPOSE.  See the GNU Lesser General Public License for more ////

//// details.                                                     ////

////                                                              ////

//// You should have received a copy of the GNU Lesser General    ////

//// Public License along with this source; if not, download it   ////

//// from http://www.opencores.org/lgpl.shtml                     ////

////                                                              ////

//////////////////////////////////////////////////////////////////////

package video_frame_pkg;

import logger_pkg::*;

typedef struct

{

  int pixel[];

} line_s;

typedef struct

{

  int x;

  int y;

} frame_coordinate_t;

typedef int flattened_frame_t[];

typedef int unsigned video_array_t[][];

// --------------------------------------------------------------------

class video_frame_class;

  logger_class log;

  rand int  frame_id;

  rand int  pixels_per_line;

  rand int  lines_per_frame;

  rand int  bits_per_pixel;

  line_s    lines[];

  string    name = "";

  string    pattern = "";

  constraint default_pixels_per_line

  {

    pixels_per_line >= 4;

    pixels_per_line % 2 == 0;

    pixels_per_line <= 16384;

  }

  constraint default_lines_per_frame

  {

    lines_per_frame >= 4;

    lines_per_frame % 2 == 0;

    lines_per_frame <= 16384;

  }

  constraint default_bits_per_pixel

  {

    bits_per_pixel >= 1 && bits_per_pixel <= 32;

  }

  //--------------------------------------------------------------------

  function new;

    this.log = new;

    this.frame_id = 0;

  endfunction: new

  // --------------------------------------------------------------------

  //

  function void init

  (

    input int pixels_per_line,

    input int lines_per_frame,

    input int bits_per_pixel,

    string    name = ""

 );

    log.info($sformatf("%m"));

    this.pixels_per_line  = pixels_per_line;

    this.lines_per_frame  = lines_per_frame;

    this.bits_per_pixel   = bits_per_pixel;

    this.name             = name;

    this.make_constant(0);

  endfunction: init

  // --------------------------------------------------------------------

  //

  extern virtual task write_pixel

  (

    input     frame_coordinate_t coordinate,

    input int pixel

  );

  extern virtual function int read_pixel

  (

    input frame_coordinate_t coordinate

  );

  extern function flattened_frame_t flatten_frame();

  extern virtual function void make_constant

  (

    input int  pixel

  );

  extern virtual function void make_counting

  (

    input int  offset = 0

  );

  extern virtual function void make_horizontal();

  extern virtual function void make_vertical();

  extern virtual function void make_random();

  extern virtual function void shift_right(ref line_s column);

  extern virtual function void copy

  (

    ref video_frame_class from

  );

  extern virtual function video_frame_class clone();

  extern virtual function int compare

  (

    input int max_mismatches,

    ref video_frame_class to

  );

  extern virtual function video_frame_class catenate_horizontally

  (

    ref video_frame_class tail

  );

  extern virtual function int compare_line

  (

    input int line,

    input int max_mismatches,

    ref video_frame_class to

  );

  extern virtual function void print_line

  (

    input int line,

    input int pixel,

    input int count

  );

  extern virtual function void print_config();

endclass: video_frame_class

  // --------------------------------------------------------------------

  //

  task

    video_frame_class::write_pixel

    (

      input     frame_coordinate_t coordinate,

      input int pixel

   );

    this.lines[coordinate.y].pixel[coordinate.x] = pixel;

  endtask: write_pixel

  // --------------------------------------------------------------------

  //

  function int video_frame_class::read_pixel

  (

    input frame_coordinate_t coordinate

  );

    read_pixel = this.lines[coordinate.y].pixel[coordinate.x];

  endfunction: read_pixel

  // --------------------------------------------------------------------

  //

  function flattened_frame_t video_frame_class::flatten_frame();

    int i = 0;

    log.info($sformatf("%m"));

    flatten_frame = new[lines_per_frame*pixels_per_line];

    foreach(this.lines[l])

      foreach(this.lines[l].pixel[p])

      begin

        flatten_frame[i] = this.lines[l].pixel[p];

        i++;

      end

  endfunction: flatten_frame

  // --------------------------------------------------------------------

  //

  function void video_frame_class::make_constant

  (

    input int  pixel

  );

    log.info($sformatf("%m"));

    this.lines = new[lines_per_frame];

    foreach(this.lines[l])

    begin

      this.lines[l].pixel = new[pixels_per_line];

      foreach(this.lines[l].pixel[p])

        this.lines[l].pixel[p] = pixel;

    end

    pattern = "constant";

  endfunction: make_constant

  // --------------------------------------------------------------------

  //

  function void video_frame_class::make_counting

  (

    input int  offset = 0

  );

    log.info($sformatf("%m"));

    this.lines = new[lines_per_frame];

    foreach(this.lines[l])

    begin

      this.lines[l].pixel = new[pixels_per_line];

      foreach(this.lines[l].pixel[p])

        this.lines[l].pixel[p] = (pixels_per_line * l) + p + offset;

    end

    pattern = "counting";

  endfunction: make_counting

  // --------------------------------------------------------------------

  //

  function void video_frame_class::make_horizontal();

    log.info($sformatf("%m"));

    this.lines = new[lines_per_frame];

    foreach(this.lines[l])

    begin

      this.lines[l].pixel = new[pixels_per_line];

      foreach(this.lines[l].pixel[p])

        this.lines[l].pixel[p] = p;

    end

    pattern = "horizontal";

  endfunction: make_horizontal

  // --------------------------------------------------------------------

  //

  function void video_frame_class::make_vertical();

    log.info($sformatf("%m"));

    this.lines = new[lines_per_frame];

    foreach(this.lines[l])

    begin

      this.lines[l].pixel = new[pixels_per_line];

      foreach(this.lines[l].pixel[p])

        this.lines[l].pixel[p] = l;

    end

    pattern = "vertical";

  endfunction: make_vertical

  // --------------------------------------------------------------------

  //

  function void video_frame_class::make_random();

    log.info($sformatf("%m"));

    this.lines = new[lines_per_frame];

    foreach(this.lines[l])

    begin

      this.lines[l].pixel = new[pixels_per_line];

      foreach(this.lines[l].pixel[p])

        this.lines[l].pixel[p] = $urandom_range(((2 ** bits_per_pixel) - 1), 0);

    end

    pattern = "random";

  endfunction: make_random

  // --------------------------------------------------------------------

  //

  function void video_frame_class::copy

  (

    ref video_frame_class from

  );

    log.info($sformatf("%m"));

    this.frame_id         = from.frame_id;

    this.pixels_per_line  = from.pixels_per_line;

    this.lines_per_frame  = from.lines_per_frame;

    this.bits_per_pixel   = from.bits_per_pixel;

    this.name             = from.name;

    this.lines            = new[this.lines_per_frame];

    foreach(this.lines[l])

    begin

      this.lines[l].pixel = new[this.pixels_per_line];

      foreach(this.lines[l].pixel[p])

        this.lines[l].pixel[p] = from.lines[l].pixel[p];

    end

  endfunction: copy

  // --------------------------------------------------------------------

  //

  function video_frame_class video_frame_class::clone();

    log.info($sformatf("%m"));

    clone = new();

    clone.copy(this);

  endfunction: clone

  // --------------------------------------------------------------------

  //

  function video_frame_class video_frame_class::catenate_horizontally

  (

    ref video_frame_class tail

  );

    log.info($sformatf("%m"));

    if(this.lines_per_frame != tail.lines_per_frame)

      return(null);

    if(this.bits_per_pixel != tail.bits_per_pixel)

      return(null);

    catenate_horizontally = new();

    catenate_horizontally.pixels_per_line  = this.pixels_per_line + tail.pixels_per_line;

    catenate_horizontally.lines_per_frame  = this.lines_per_frame;

    catenate_horizontally.bits_per_pixel   = this.bits_per_pixel;

    catenate_horizontally.name             = this.name;

    catenate_horizontally.lines            = new[catenate_horizontally.lines_per_frame];

    foreach(catenate_horizontally.lines[l])

    begin

      catenate_horizontally.lines[l].pixel = new[catenate_horizontally.pixels_per_line];

      foreach(this.lines[l].pixel[p])

        catenate_horizontally.lines[l].pixel[p] = this.lines[l].pixel[p];

      foreach(tail.lines[l].pixel[p])

        catenate_horizontally.lines[l].pixel[p + this.pixels_per_line] = tail.lines[l].pixel[p];

    end

  endfunction: catenate_horizontally

  // --------------------------------------------------------------------

  //

  function void video_frame_class::shift_right(ref line_s column);

    log.info($sformatf("%m"));

    foreach(this.lines[l])

      for(int p = pixels_per_line - 1; p > 0; p--)

        this.lines[l].pixel[p] = this.lines[l].pixel[p - 1];

    foreach(this.lines[l])

      this.lines[l].pixel[0] = column.pixel[l];

  endfunction: shift_right

  // --------------------------------------------------------------------

  //

  function int video_frame_class::compare_line

  (

    input int line,

    input int max_mismatches,

    ref video_frame_class to

 );

    int mismatch_count = 0;

    if(to.bits_per_pixel != this.bits_per_pixel)

    begin

      log.error($sformatf("to.bits_per_pixel != this.bits_per_pixel | %s", name));

      return(-3);

    end

      foreach(this.lines[line].pixel[p])

        if(to.lines[line].pixel[p] != this.lines[line].pixel[p])

        begin

          if(max_mismatches > 0)

            mismatch_count++;

            log.error($sformatf("mismatch @ frame[%4h][%4h] | to == %4h | this == %4h  | %s",

                      line, p, to.lines[line].pixel[p], this.lines[line].pixel[p], name));

          if(mismatch_count > max_mismatches)

            return(mismatch_count);

        end

      return(mismatch_count);

  endfunction: compare_line

  // --------------------------------------------------------------------

  //

  function int video_frame_class::compare

  (

    input int max_mismatches,

    ref video_frame_class to

 );

    int mismatch_count = 0;

    log.info($sformatf("%m"));

    if(to.pixels_per_line != this.pixels_per_line)

    begin

      log.error($sformatf("to.pixels_per_line != this.pixels_per_line | %s", name));

      return(-1);

    end

    if(to.lines_per_frame != this.lines_per_frame)

    begin

      log.error($sformatf("to.lines_per_frame != this.lines_per_frame | %s", name));

      return(-2);

    end

    if(to.bits_per_pixel != this.bits_per_pixel)

    begin

      log.error($sformatf("to.bits_per_pixel != this.bits_per_pixel | %s", name));

      return(-3);

    end

      foreach(this.lines[l])

      begin

        foreach(this.lines[l].pixel[p])

          if(to.lines[l].pixel[p] != this.lines[l].pixel[p])

          begin

            if(max_mismatches > 0)

              mismatch_count++;

              log.error($sformatf("mismatch @ frame[%4h][%4h] | to == %4h | this == %4h  | %s", l, p, to.lines[l].pixel[p], this.lines[l].pixel[p], name));

            if(mismatch_count > max_mismatches)

              return(mismatch_count);

          end

      end

      return(mismatch_count);

  endfunction: compare

  // --------------------------------------------------------------------

  //

  function void video_frame_class::print_line

  (

    input int line,

    input int pixel,

    input int count

  );

    log.info($sformatf("%m"));

    for(int i = 0; i < count; i++)

      log.display($sformatf("%4h @ frame[%4h][%4h] | %s", this.lines[line].pixel[(pixel + i)], line, (pixel + i), name));

  endfunction: print_line

  // --------------------------------------------------------------------

  //

  function void video_frame_class::print_config();

    log.display($sformatf("%m | frame_id         = %06d  | %s", frame_id, name));

    log.display($sformatf("%m | pixels_per_line  = %06d  | %s", pixels_per_line, name));

    log.display($sformatf("%m | lines_per_frame  = %06d  | %s", lines_per_frame, name));

    log.display($sformatf("%m | bits_per_pixel   = %06d  | %s", bits_per_pixel, name));

    log.display($sformatf("%m | pattern          = %s    | %s", pattern, name));

  endfunction: print_config

endpackage: video_frame_pkg