예제 #1
0
    def bench_quant():
        """instantiation of quantizer module and clock"""
        inst = quantizer(clock, reset, quanti_datastream,
                         quant_ctrl, quanto_datastream)

        inst_clock = clock_driver(clock)

        @instance
        def tbstim():
            """we send test cases here"""

            # reset the block before processing
            yield pulse_reset(reset, clock)

            # select Cb or Cr component
            color = component.y2_space

            # process Cb or Cr component
            yield quant_top_block_process(
                clock, quant_ctrl, color, quanto_datastream,
                quanti_datastream, quant_in, quant_rom, max_addr, 1)

            print ("===============================================")

            # select Y1 or Y2 component
            color = component.cr_space

            # process Cb or Cr component
            yield quant_top_block_process(
                clock, quant_ctrl, color, quanto_datastream,
                quanti_datastream, quant_in, quant_rom, max_addr, 1)

            raise StopSimulation

        return tbstim, inst, inst_clock
예제 #2
0
    def bench_quant():
        """instantiation of quantizer module and clock"""
        inst = quantizer(clock, reset, quanti_datastream, quant_ctrl,
                         quanto_datastream)

        inst_clock = clock_driver(clock)

        @instance
        def tbstim():
            """we send test cases here"""

            # reset the block before processing
            yield pulse_reset(reset, clock)

            # select Cb or Cr component
            color = component.y2_space

            # process Cb or Cr component
            yield quant_top_block_process(clock, quant_ctrl, color,
                                          quanto_datastream, quanti_datastream,
                                          quant_in, quant_rom, max_addr, 1)

            print("===============================================")

            # select Y1 or Y2 component
            color = component.cr_space

            # process Cb or Cr component
            yield quant_top_block_process(clock, quant_ctrl, color,
                                          quanto_datastream, quanti_datastream,
                                          quant_in, quant_rom, max_addr, 1)

            raise StopSimulation

        return tbstim, inst, inst_clock
예제 #3
0
    def bench_quant_top_core():
        """wrapper used for conversion purpose"""

        # instantiatiom of quantizer, clock and reset
        inst = quantizer(clock, reset, quanti_datastream,
                         quant_ctrl, quanto_datastream)

        inst_clock = clock_driver(clock)
        inst_reset = reset_on_start(reset, clock)

        @instance
        def tbstim():
            """dummy tests to convert the module"""
            yield clock.posedge
            print ("Conversion done!!")
            raise StopSimulation

        return tbstim, inst, inst_clock, inst_reset
예제 #4
0
    def bench_quant_top_core():
        """wrapper used for conversion purpose"""

        # instantiatiom of quantizer, clock and reset
        inst = quantizer(clock, reset, quanti_datastream, quant_ctrl,
                         quanto_datastream)

        inst_clock = clock_driver(clock)
        inst_reset = reset_on_start(reset, clock)

        @instance
        def tbstim():
            """dummy tests to convert the module"""
            yield clock.posedge
            print("Conversion done!!")
            raise StopSimulation

        return tbstim, inst, inst_clock, inst_reset
예제 #5
0
def backend(clock, reset, start, data_in, write_addr,
            write_enable, data_out, ready, addr, num_enc_bytes):

    """
    Constants:

    width_data : width of the input data
    width_addr : width of the address accessed by a module
    width_runlength : width of the runlength value
    width_size : width of the size value
    width_out_byte : width of output byte
    width_num_bytes : max encoded bytes width

    """
    width_data = len(data_in)
    width_addr = len(write_addr)
    width_num_bytes = len(num_enc_bytes)
    width_runlength = 4
    width_byte = 8
    width_size = width_data.bit_length()

    # used by quantizer to read data from input DRAM
    read_addr = Signal(intbv(0)[width_addr:])
    # output from the input DRAM
    data_in_quantiser = Signal(intbv(0)[width_data:])

    # quantizer data and control streams
    quanti_datastream = QuantIODataStream(width_data, width_addr-1)
    quanto_datastream = QuantIODataStream(width_data, width_addr-1)
    quant_ctrl = QuantCtrl()

    # rle data and control streams
    rle_input_datastream = DataStream(width_data, width_addr-1)
    rle_outputs = BufferDataBus(width_data, width_size, width_runlength)
    rle_config = RLEConfig()

    huffmandatastream = HuffmanDataStream(width_runlength, width_size,
                                          width_data, width_addr-1)
    bufferdatabus = HuffBufferDataBus(width_byte)
    huffmancntrl = HuffmanCntrl()
    img_size = ImgSize(100, 100)
    rle_fifo_empty = Signal(bool(0))

    bs_in_stream = BSInputDataStream(width_byte)
    bs_out_stream = BSOutputDataStream(width_byte, width_num_bytes)
    bs_cntrl = BScntrl()

    ready_rle = Signal(bool(0))
    ready_huffman = Signal(bool(0))

    # control signals
    wait = Signal(intbv(0)[3:])
    enable_huff_read = Signal(bool(0))
    counter = Signal(intbv(0)[3:])
    value = Signal(intbv(4)[4:])
    ready_quant = Signal(bool(0))
    ready_bytestuffer = Signal(bool(0))
    enable_huff_read_s = Signal(bool(0))

    # instantiation of DRAM
    inst_dbuf = dram(clock, data_in, write_addr, read_addr,
                     write_enable, data_in_quantiser)

    @always_seq(clock.posedge, reset=reset)
    def control_ready_valid():
        """control flow that operated between blocks"""

        # initially when the first block enters
        if wait == 0:
            if start:
                quant_ctrl.start.next = True
                quant_ctrl.color_component.next = 1
            else:
                quant_ctrl.start.next = False
                if quant_ctrl.ready:
                    ready.next = True
                    wait.next = 1

        # when both rle and quantizer are ready
        elif wait == 1:
            ready.next = False
            if start:
                rle_config.start.next = True
                quant_ctrl.start.next = True
                quant_ctrl.color_component.next = 2
                rle_config.color_component.next = 1
            else:
                rle_config.start.next = False
                quant_ctrl.start.next = False
                if quant_ctrl.ready:
                    ready_quant.next = True
                if rle_config.ready:
                    ready_rle.next = True

                if ready_quant and ready_rle:
                    ready.next = True
                    ready_rle.next = False
                    ready_quant.next = False
                    wait.next = 2

        # when quantizer, rle and huffman are ready
        elif wait == 2:
            ready.next = False
            if start:
                rle_config.start.next = True
                quant_ctrl.start.next = True
                huffmancntrl.start.next = True
                huffmancntrl.color_component.next = 1
                rle_config.color_component.next = 2
                quant_ctrl.color_component.next = 3
            else:
                rle_config.start.next = False
                quant_ctrl.start.next = False
                huffmancntrl.start.next = False
                if quant_ctrl.ready:
                    ready_quant.next = True
                if rle_config.ready:
                    ready_rle.next = True
                if huffmancntrl.ready:
                    ready_huffman.next = True

                if ready_quant and ready_rle and ready_huffman:
                    ready.next = True
                    ready_rle.next = False
                    ready_quant.next = False
                    ready_huffman.next = False
                    wait.next = 3

        # when all the four blocks are ready
        elif wait == 3:
            ready.next = False
            if start:
                rle_config.start.next = True
                quant_ctrl.start.next = True
                huffmancntrl.start.next = True
                bs_cntrl.start.next = True

                if huffmancntrl.color_component == 3:
                    huffmancntrl.color_component.next = 1
                if quant_ctrl.color_component == 3:
                    quant_ctrl.color_component.next = 1
                if rle_config.color_component == 3:
                    rle_config.color_component.next = 1
                else:
                    huffmancntrl.color_component.next = (
                        huffmancntrl.color_component + 1)

                    rle_config.color_component.next = (
                        rle_config.color_component + 1)

                    quant_ctrl.color_component.next = (
                        quant_ctrl.color_component + 1)

            else:
                rle_config.start.next = False
                quant_ctrl.start.next = False
                huffmancntrl.start.next = False
                bs_cntrl.start.next = False

                if quant_ctrl.ready:
                    ready_quant.next = True
                if rle_config.ready:
                    ready_rle.next = True
                if huffmancntrl.ready:
                    ready_huffman.next = True
                if bs_cntrl.ready:
                    ready_bytestuffer.next = True

                if (ready_quant and ready_rle) and (
                        ready_huffman and ready_bytestuffer):

                    ready.next = True
                    ready_rle.next = False
                    ready_quant.next = False
                    ready_huffman.next = False
                    ready_bytestuffer.next = False
                    wait.next = 3

    @always_comb
    def assign_quant_in():
        """quantizer and DRAM connections"""
        quanti_datastream.data.next = data_in_quantiser
        read_addr.next = concat(quanti_datastream.buffer_sel,
                                quanti_datastream.addr.next)

    # instantiation of quantizer module
    inst_quant = quantizer(clock, reset, quanti_datastream,
                           quant_ctrl, quanto_datastream)

    @always_comb
    def assign_rle_in():
        """connections between quantizer and RLE module"""
        rle_input_datastream.data_in.next = quanto_datastream.data
        quanto_datastream.addr.next = concat(rle_input_datastream.buffer_sel,
                                             rle_input_datastream.read_addr)

        quanto_datastream.buffer_sel.next = rle_input_datastream.buffer_sel

    # instantiation of RLE module
    inst_rle = rlencoder(clock, reset, rle_input_datastream,
                         rle_outputs, rle_config)

    @always_seq(clock.posedge, reset=reset)
    def counter_huff():
        """counter that increments till three"""

        if huffmancntrl.start:
            enable_huff_read.next = True
            rle_outputs.read_enable.next = True

        else:
            rle_outputs.read_enable.next = False

        if enable_huff_read:
            enable_huff_read_s.next = True
            enable_huff_read.next = False

        if enable_huff_read_s:
            if not rle_outputs.fifo_empty:
                counter.next = counter + 1
            else:
                counter.next = 0
                rle_outputs.read_enable.next = False

        if counter >= value:
            rle_outputs.read_enable.next = not rle_outputs.read_enable
            counter.next = 0
            if huffmancntrl.ready or rle_outputs.fifo_empty:
                rle_outputs.read_enable.next = False
                enable_huff_read_s.next = False

        if huffmancntrl.ready:
            rle_outputs.read_enable.next = False
            enable_huff_read_s.next = False
            counter.next = 0

    @always_comb
    def assign_huffman_in():
        """"Huffman Module and RLE Module connections"""
        huffmandatastream.runlength.next = rle_outputs.runlength
        huffmandatastream.vli_size.next = rle_outputs.size
        huffmandatastream.vli.next = rle_outputs.amplitude
        huffmandatastream.data_valid.next = rle_outputs.read_enable
        rle_fifo_empty.next = rle_outputs.fifo_empty
        rle_outputs.buffer_sel.next = huffmandatastream.buffer_sel

    # instantiation of Huffman Module
    inst_huffman = huffman(clock, reset, huffmancntrl, bufferdatabus,
                           huffmandatastream, img_size, rle_fifo_empty)

    @always_comb
    def assign_bs_in():
        """connections between ByteStuffer and Huffman Module"""
        bs_in_stream.data_in.next = bufferdatabus.huf_packed_byte
        bs_in_stream.fifo_empty.next = bufferdatabus.fifo_empty
        bufferdatabus.read_req.next = bs_in_stream.read

    @always_comb
    def assig_buff():
        """assign buffers between ByteStuffer and Huffman"""
        bufferdatabus.buffer_sel.next = bs_in_stream.buffer_sel

    # instantiation of Byte stuffer
    inst_bytestuffer = bytestuffer(clock, reset, bs_in_stream,
                                   bs_out_stream, bs_cntrl, num_enc_bytes)

    @always_comb
    def assign_out():
        """output from the Backend Module"""
        data_out.next = bs_out_stream.byte
        addr.next = bs_out_stream.addr

    return (inst_dbuf, control_ready_valid, assign_quant_in,
            inst_quant, assign_rle_in, inst_rle, counter_huff,
            assign_huffman_in, inst_huffman, assign_bs_in,
            assig_buff, inst_bytestuffer, assign_out)
예제 #6
0
def backend(clock, reset, start, data_in, write_addr, write_enable, data_out,
            ready, addr, num_enc_bytes):
    """
    Constants:

    width_data : width of the input data
    width_addr : width of the address accessed by a module
    width_runlength : width of the runlength value
    width_size : width of the size value
    width_out_byte : width of output byte
    width_num_bytes : max encoded bytes width

    """
    width_data = len(data_in)
    width_addr = len(write_addr)
    width_num_bytes = len(num_enc_bytes)
    width_runlength = 4
    width_byte = 8
    width_size = width_data.bit_length()

    # used by quantizer to read data from input DRAM
    read_addr = Signal(intbv(0)[width_addr:])
    # output from the input DRAM
    data_in_quantiser = Signal(intbv(0)[width_data:])

    # quantizer data and control streams
    quanti_datastream = QuantIODataStream(width_data, width_addr - 1)
    quanto_datastream = QuantIODataStream(width_data, width_addr - 1)
    quant_ctrl = QuantCtrl()

    # rle data and control streams
    rle_input_datastream = DataStream(width_data, width_addr - 1)
    rle_outputs = BufferDataBus(width_data, width_size, width_runlength)
    rle_config = RLEConfig()

    huffmandatastream = HuffmanDataStream(width_runlength, width_size,
                                          width_data, width_addr - 1)
    bufferdatabus = HuffBufferDataBus(width_byte)
    huffmancntrl = HuffmanCntrl()
    img_size = ImgSize(100, 100)
    rle_fifo_empty = Signal(bool(0))

    bs_in_stream = BSInputDataStream(width_byte)
    bs_out_stream = BSOutputDataStream(width_byte, width_num_bytes)
    bs_cntrl = BScntrl()

    ready_rle = Signal(bool(0))
    ready_huffman = Signal(bool(0))

    # control signals
    wait = Signal(intbv(0)[3:])
    enable_huff_read = Signal(bool(0))
    counter = Signal(intbv(0)[3:])
    value = Signal(intbv(4)[4:])
    ready_quant = Signal(bool(0))
    ready_bytestuffer = Signal(bool(0))
    enable_huff_read_s = Signal(bool(0))

    # instantiation of DRAM
    inst_dbuf = dram(clock, data_in, write_addr, read_addr, write_enable,
                     data_in_quantiser)

    @always_seq(clock.posedge, reset=reset)
    def control_ready_valid():
        """control flow that operated between blocks"""

        # initially when the first block enters
        if wait == 0:
            if start:
                quant_ctrl.start.next = True
                quant_ctrl.color_component.next = 1
            else:
                quant_ctrl.start.next = False
                if quant_ctrl.ready:
                    ready.next = True
                    wait.next = 1

        # when both rle and quantizer are ready
        elif wait == 1:
            ready.next = False
            if start:
                rle_config.start.next = True
                quant_ctrl.start.next = True
                quant_ctrl.color_component.next = 2
                rle_config.color_component.next = 1
            else:
                rle_config.start.next = False
                quant_ctrl.start.next = False
                if quant_ctrl.ready:
                    ready_quant.next = True
                if rle_config.ready:
                    ready_rle.next = True

                if ready_quant and ready_rle:
                    ready.next = True
                    ready_rle.next = False
                    ready_quant.next = False
                    wait.next = 2

        # when quantizer, rle and huffman are ready
        elif wait == 2:
            ready.next = False
            if start:
                rle_config.start.next = True
                quant_ctrl.start.next = True
                huffmancntrl.start.next = True
                huffmancntrl.color_component.next = 1
                rle_config.color_component.next = 2
                quant_ctrl.color_component.next = 3
            else:
                rle_config.start.next = False
                quant_ctrl.start.next = False
                huffmancntrl.start.next = False
                if quant_ctrl.ready:
                    ready_quant.next = True
                if rle_config.ready:
                    ready_rle.next = True
                if huffmancntrl.ready:
                    ready_huffman.next = True

                if ready_quant and ready_rle and ready_huffman:
                    ready.next = True
                    ready_rle.next = False
                    ready_quant.next = False
                    ready_huffman.next = False
                    wait.next = 3

        # when all the four blocks are ready
        elif wait == 3:
            ready.next = False
            if start:
                rle_config.start.next = True
                quant_ctrl.start.next = True
                huffmancntrl.start.next = True
                bs_cntrl.start.next = True

                if huffmancntrl.color_component == 3:
                    huffmancntrl.color_component.next = 1
                if quant_ctrl.color_component == 3:
                    quant_ctrl.color_component.next = 1
                if rle_config.color_component == 3:
                    rle_config.color_component.next = 1
                else:
                    huffmancntrl.color_component.next = (
                        huffmancntrl.color_component + 1)

                    rle_config.color_component.next = (
                        rle_config.color_component + 1)

                    quant_ctrl.color_component.next = (
                        quant_ctrl.color_component + 1)

            else:
                rle_config.start.next = False
                quant_ctrl.start.next = False
                huffmancntrl.start.next = False
                bs_cntrl.start.next = False

                if quant_ctrl.ready:
                    ready_quant.next = True
                if rle_config.ready:
                    ready_rle.next = True
                if huffmancntrl.ready:
                    ready_huffman.next = True
                if bs_cntrl.ready:
                    ready_bytestuffer.next = True

                if (ready_quant and ready_rle) and (ready_huffman
                                                    and ready_bytestuffer):

                    ready.next = True
                    ready_rle.next = False
                    ready_quant.next = False
                    ready_huffman.next = False
                    ready_bytestuffer.next = False
                    wait.next = 3

    @always_comb
    def assign_quant_in():
        """quantizer and DRAM connections"""
        quanti_datastream.data.next = data_in_quantiser
        read_addr.next = concat(quanti_datastream.buffer_sel,
                                quanti_datastream.addr.next)

    # instantiation of quantizer module
    inst_quant = quantizer(clock, reset, quanti_datastream, quant_ctrl,
                           quanto_datastream)

    @always_comb
    def assign_rle_in():
        """connections between quantizer and RLE module"""
        rle_input_datastream.data_in.next = quanto_datastream.data
        quanto_datastream.addr.next = concat(rle_input_datastream.buffer_sel,
                                             rle_input_datastream.read_addr)

        quanto_datastream.buffer_sel.next = rle_input_datastream.buffer_sel

    # instantiation of RLE module
    inst_rle = rlencoder(clock, reset, rle_input_datastream, rle_outputs,
                         rle_config)

    @always_seq(clock.posedge, reset=reset)
    def counter_huff():
        """counter that increments till three"""

        if huffmancntrl.start:
            enable_huff_read.next = True
            rle_outputs.read_enable.next = True

        else:
            rle_outputs.read_enable.next = False

        if enable_huff_read:
            enable_huff_read_s.next = True
            enable_huff_read.next = False

        if enable_huff_read_s:
            if not rle_outputs.fifo_empty:
                counter.next = counter + 1
            else:
                counter.next = 0
                rle_outputs.read_enable.next = False

        if counter >= value:
            rle_outputs.read_enable.next = not rle_outputs.read_enable
            counter.next = 0
            if huffmancntrl.ready or rle_outputs.fifo_empty:
                rle_outputs.read_enable.next = False
                enable_huff_read_s.next = False

        if huffmancntrl.ready:
            rle_outputs.read_enable.next = False
            enable_huff_read_s.next = False
            counter.next = 0

    @always_comb
    def assign_huffman_in():
        """"Huffman Module and RLE Module connections"""
        huffmandatastream.runlength.next = rle_outputs.runlength
        huffmandatastream.vli_size.next = rle_outputs.size
        huffmandatastream.vli.next = rle_outputs.amplitude
        huffmandatastream.data_valid.next = rle_outputs.read_enable
        rle_fifo_empty.next = rle_outputs.fifo_empty
        rle_outputs.buffer_sel.next = huffmandatastream.buffer_sel

    # instantiation of Huffman Module
    inst_huffman = huffman(clock, reset, huffmancntrl, bufferdatabus,
                           huffmandatastream, img_size, rle_fifo_empty)

    @always_comb
    def assign_bs_in():
        """connections between ByteStuffer and Huffman Module"""
        bs_in_stream.data_in.next = bufferdatabus.huf_packed_byte
        bs_in_stream.fifo_empty.next = bufferdatabus.fifo_empty
        bufferdatabus.read_req.next = bs_in_stream.read

    @always_comb
    def assig_buff():
        """assign buffers between ByteStuffer and Huffman"""
        bufferdatabus.buffer_sel.next = bs_in_stream.buffer_sel

    # instantiation of Byte stuffer
    inst_bytestuffer = bytestuffer(clock, reset, bs_in_stream, bs_out_stream,
                                   bs_cntrl, num_enc_bytes)

    @always_comb
    def assign_out():
        """output from the Backend Module"""
        data_out.next = bs_out_stream.byte
        addr.next = bs_out_stream.addr

    return (inst_dbuf, control_ready_valid, assign_quant_in, inst_quant,
            assign_rle_in, inst_rle, counter_huff, assign_huffman_in,
            inst_huffman, assign_bs_in, assig_buff, inst_bytestuffer,
            assign_out)