Subversion Repositories mpeg2fpga

/* 
 * syncgen_intf.v
 * 
 * Copyright (c) 2007 Koen De Vleeschauwer. 
 * 
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
 * SUCH DAMAGE.
 */
 
/*
 * syncgen_intf - interface between decoder clock region and video
 * synchronization generator.
 */
 
`include "timescale.v"
 
`undef DEBUG
//`define DEBUG 1
 
module syncgen_intf    
                  (clk, clk_en, rst,
                   horizontal_size, vertical_size, display_horizontal_size, display_vertical_size,
                   syncgen_rst,
                   horizontal_resolution, horizontal_sync_start, horizontal_sync_end, horizontal_length,
                   vertical_resolution, vertical_sync_start, vertical_sync_end, horizontal_halfline, vertical_length,
                   interlaced, clip_display_size, pixel_repetition,
                   h_pos, v_pos, pixel_en, h_sync, v_sync, c_sync, h_blank, v_blank);
 
  input            clk;
  input            clk_en;
  input            rst;
 
  input      [13:0]horizontal_size;               /* par. 6.2.2.1, par. 6.3.3 */
  input      [13:0]vertical_size;                 /* par. 6.2.2.1, par. 6.3.3 */
  input      [13:0]display_horizontal_size;       /* par. 6.2.2.4, par. 6.3.6 */
  input      [13:0]display_vertical_size;         /* par. 6.2.2.4, par. 6.3.6 */
 
  input            syncgen_rst;                   /* reset sync generator whenever modeline parameter is changed */
  input      [11:0]horizontal_resolution;         /* horizontal resolution. number of dots per line */
  input      [11:0]horizontal_sync_start;         /* the dot the horizontal sync pulse begins. */
  input      [11:0]horizontal_sync_end;           /* the dot the horizontal sync pulse ends. */
  input      [11:0]horizontal_length;             /* total horizontal length */
  input      [11:0]vertical_resolution;           /* vertical resolution. number of visible lines per frame (progressive) or field (interlaced) */
  input      [11:0]vertical_sync_start;           /* the line number within the frame (progressive) or field (interlaced) the vertical sync pulse begins. */
  input      [11:0]vertical_sync_end;             /* the line number within the frame (progressive) or field (interlaced) the vertical sync pulse ends. */
  input      [11:0]horizontal_halfline;           /* the dot the vertical sync begins on odd frames of interlaced video. Not used in progressive mode. */
  input      [11:0]vertical_length;               /* total number of lines of a vertical frame (progressive) or field (interlaced) */
  input            interlaced;                    /* asserted if interlaced output required. */
  input            pixel_repetition;              /* asserted if each pixel drawn twice */
  input            clip_display_size;             /* assert to clip image to (display_horizontal_size, display_vertical_size) */
 
  output     [11:0]h_pos;                         /* horizontal position */
  output     [11:0]v_pos;                         /* vertical position */
  output           pixel_en;                      /* pixel enable, asserted when pixel drawn */
  output           h_sync;                        /* horizontal sync */
  output           v_sync;                        /* vertical sync */
  output           c_sync;                        /* complex sync */
  output           h_blank;                       /* horizontal blanking */
  output           v_blank;                       /* vertical blanking */
 
  wire             dot_syncgen_rst;               /* sync generator reset, synchronized to dot_clk */
  wire       [13:0]dot_horizontal_size;
  wire       [13:0]dot_vertical_size;
  wire       [13:0]dot_display_horizontal_size;
  wire       [13:0]dot_display_vertical_size;
  wire       [11:0]dot_horizontal_resolution;
  wire       [11:0]dot_horizontal_sync_start;
  wire       [11:0]dot_horizontal_sync_end;
  wire       [11:0]dot_horizontal_length;
  wire       [11:0]dot_vertical_resolution;
  wire       [11:0]dot_vertical_sync_start;
  wire       [11:0]dot_vertical_sync_end;
  wire       [11:0]dot_horizontal_halfline;
  wire       [11:0]dot_vertical_length;
  wire             dot_interlaced;
  wire             dot_pixel_repetition;
  wire             dot_clip_display_size;
 
  /* 
   * Synchronize sync generator reset signal with dot clock.
   */
 
 
  sync_reset syncgen_sreset (
    .clk(clk),
    .asyncrst(syncgen_rst),
    .syncrst(dot_syncgen_rst)
     );
 
  /* 
   * Synchronize video parameters with dot clock 
   */
 
  sync_reg #(.width(14)) sync_horizontal_size (
    .clk(clk),
    .rst(rst),
    .asyncreg(horizontal_size),
    .syncreg(dot_horizontal_size)
    );
 
  sync_reg #(.width(14)) sync_vertical_size (
    .clk(clk),
    .rst(rst),
    .asyncreg(vertical_size),
    .syncreg(dot_vertical_size)
    );
 
  sync_reg #(.width(14)) sync_display_horizontal_size (
    .clk(clk),
    .rst(rst),
    .asyncreg(display_horizontal_size),
    .syncreg(dot_display_horizontal_size)
    );
 
  sync_reg #(.width(14)) sync_display_vertical_size (
    .clk(clk),
    .rst(rst),
    .asyncreg(display_vertical_size),
    .syncreg(dot_display_vertical_size)
    );
 
  sync_reg #(.width(12)) sync_horizontal_resolution (
    .clk(clk),
    .rst(rst),
    .asyncreg(horizontal_resolution),
    .syncreg(dot_horizontal_resolution)
    );
 
  sync_reg #(.width(12)) sync_horizontal_sync_start (
    .clk(clk),
    .rst(rst),
    .asyncreg(horizontal_sync_start),
    .syncreg(dot_horizontal_sync_start)
    );
 
  sync_reg #(.width(12)) sync_horizontal_sync_end (
    .clk(clk),
    .rst(rst),
    .asyncreg(horizontal_sync_end),
    .syncreg(dot_horizontal_sync_end)
    );
 
  sync_reg #(.width(12)) sync_horizontal_length (
    .clk(clk),
    .rst(rst),
    .asyncreg(horizontal_length),
    .syncreg(dot_horizontal_length)
    );
 
  sync_reg #(.width(12)) sync_vertical_resolution (
    .clk(clk),
    .rst(rst),
    .asyncreg(vertical_resolution),
    .syncreg(dot_vertical_resolution)
    );
 
  sync_reg #(.width(12)) sync_vertical_sync_start (
    .clk(clk),
    .rst(rst),
    .asyncreg(vertical_sync_start),
    .syncreg(dot_vertical_sync_start)
    );
 
  sync_reg #(.width(12)) sync_vertical_sync_end (
    .clk(clk),
    .rst(rst),
    .asyncreg(vertical_sync_end),
    .syncreg(dot_vertical_sync_end)
    );
 
  sync_reg #(.width(12)) sync_horizontal_halfline (
    .clk(clk),
    .rst(rst),
    .asyncreg(horizontal_halfline),
    .syncreg(dot_horizontal_halfline)
    );
 
  sync_reg #(.width(12)) sync_vertical_length (
    .clk(clk),
    .rst(rst),
    .asyncreg(vertical_length),
    .syncreg(dot_vertical_length)
    );
 
  sync_reg #(.width(1)) sync_interlaced (
    .clk(clk),
    .rst(rst),
    .asyncreg(interlaced),
    .syncreg(dot_interlaced)
    );
 
  sync_reg #(.width(1)) sync_pixel_repetition (
    .clk(clk),
    .rst(rst),
    .asyncreg(pixel_repetition),
    .syncreg(dot_pixel_repetition)
    );
 
  sync_reg #(.width(1)) sync_clip_display_size (
    .clk(clk),
    .rst(rst),
    .asyncreg(clip_display_size),
    .syncreg(dot_clip_display_size)
    );
 
  /* 
   * Pixel repetition
   */
 
  reg        [13:0]syncgen_horizontal_size;
  reg        [13:0]syncgen_display_horizontal_size;
  reg        [11:0]syncgen_horizontal_resolution;
  reg        [11:0]syncgen_horizontal_sync_start;
  reg        [11:0]syncgen_horizontal_sync_end;
  reg        [11:0]syncgen_horizontal_length;
  reg        [11:0]syncgen_horizontal_halfline;
 
  always @(posedge clk)
    if (~rst) syncgen_horizontal_size <= 14'b0;
    else if (clk_en) syncgen_horizontal_size <= dot_pixel_repetition ? {dot_horizontal_size[12:0], 1'b0} : dot_horizontal_size;
    else syncgen_horizontal_size <= syncgen_horizontal_size;
 
  always @(posedge clk)
    if (~rst) syncgen_display_horizontal_size <= 14'b0;
    else if (clk_en) syncgen_display_horizontal_size <= (dot_pixel_repetition && (dot_display_horizontal_size != 14'd0)) ? {dot_display_horizontal_size[12:0], 1'b1} : dot_display_horizontal_size;
    else syncgen_display_horizontal_size <= syncgen_display_horizontal_size;
 
  always @(posedge clk)
    if (~rst) syncgen_horizontal_resolution <= 12'b0;
    else if (clk_en) syncgen_horizontal_resolution <= dot_pixel_repetition ? {dot_horizontal_resolution[10:0], 1'b1} : dot_horizontal_resolution;
    else syncgen_horizontal_resolution <= syncgen_horizontal_resolution;
 
  always @(posedge clk)
    if (~rst) syncgen_horizontal_sync_start <= 12'b0;
    else if (clk_en) syncgen_horizontal_sync_start <= dot_pixel_repetition ? {dot_horizontal_sync_start[10:0], 1'b1} : dot_horizontal_sync_start;
    else syncgen_horizontal_sync_start <= syncgen_horizontal_sync_start;
 
  always @(posedge clk)
    if (~rst) syncgen_horizontal_sync_end <= 12'b0;
    else if (clk_en) syncgen_horizontal_sync_end <= dot_pixel_repetition ? {dot_horizontal_sync_end[10:0], 1'b1} : dot_horizontal_sync_end;
    else syncgen_horizontal_sync_end <= syncgen_horizontal_sync_end;
 
  always @(posedge clk)
    if (~rst) syncgen_horizontal_length <= 12'b0;
    else if (clk_en) syncgen_horizontal_length <= dot_pixel_repetition ? {dot_horizontal_length[10:0], 1'b1} : dot_horizontal_length;
    else syncgen_horizontal_length <= syncgen_horizontal_length;
 
  always @(posedge clk)
    if (~rst) syncgen_horizontal_halfline <= 12'b0;
    else if (clk_en) syncgen_horizontal_halfline <= dot_pixel_repetition ? {dot_horizontal_halfline[10:0], 1'b1}     : dot_horizontal_halfline;
    else syncgen_horizontal_halfline <= syncgen_horizontal_halfline;
 
  /* 
   * Synchronisation generator
   */
 
  sync_gen sync_gen (
    .clk(clk), 
    .clk_en(clk_en), 
    .rst(dot_syncgen_rst), 
    .horizontal_size(syncgen_horizontal_size), 
    .vertical_size(dot_vertical_size), 
    .display_horizontal_size(syncgen_display_horizontal_size), 
    .display_vertical_size(dot_display_vertical_size), 
    .horizontal_resolution(syncgen_horizontal_resolution), 
    .horizontal_sync_start(syncgen_horizontal_sync_start), 
    .horizontal_sync_end(syncgen_horizontal_sync_end), 
    .horizontal_length(syncgen_horizontal_length), 
    .vertical_resolution(dot_vertical_resolution), 
    .vertical_sync_start(dot_vertical_sync_start), 
    .vertical_sync_end(dot_vertical_sync_end), 
    .horizontal_halfline(syncgen_horizontal_halfline), 
    .vertical_length(dot_vertical_length), 
    .interlaced(dot_interlaced), 
    .clip_display_size(dot_clip_display_size), 
    .h_pos(h_pos), 
    .v_pos(v_pos), 
    .pixel_en(pixel_en), 
    .h_sync(h_sync), 
    .v_sync(v_sync), 
    .c_sync(c_sync), 
    .h_blank(h_blank), 
    .v_blank(v_blank)
    );
 
endmodule
/* not truncated */