|
//---------------------------------------------------------------------------
|
|
//-- (c) 2016 Alexey Spirkov
|
|
//-- I am happy for anyone to use this for non-commercial use.
|
|
//-- If my verilog/vhdl/c files are used commercially or otherwise sold,
|
|
//-- please contact me for explicit permission at me _at_ alsp.net.
|
|
//-- This applies for source and binary form and derived works.
|
|
//
|
|
//-- Audio and infoframe packet generation mechanizms based on Charlie Cole 2015
|
|
//-- design of HDMI output for Neo Geo MVS
|
|
|
|
module hdmidataencoder
|
|
#(parameter FREQ=27000000, FS=48000, CTS=27000, N=6144)
|
|
(
|
|
input i_pixclk,
|
|
input i_hSync,
|
|
input i_vSync,
|
|
input i_blank,
|
|
input [15:0] i_audioL,
|
|
input [15:0] i_audioR,
|
|
output [3:0] o_d0,
|
|
output [3:0] o_d1,
|
|
output [3:0] o_d2,
|
|
output o_data
|
|
);
|
|
|
|
`define AUDIO_TIMER_ADDITION FS/1000
|
|
`define AUDIO_TIMER_LIMIT FREQ/1000
|
|
localparam [191:0] channelStatus = (FS == 48000)?192'hc202004004:(FS == 44100)?192'hc200004004:192'hc203004004;
|
|
localparam [55:0] audioRegenPacket = {N[7:0], N[15:8], 8'h00, CTS[7:0], CTS[15:8], 16'h0000};
|
|
reg [23:0] audioPacketHeader;
|
|
reg [55:0] audioSubPacket[3:0];
|
|
reg [7:0] channelStatusIdx;
|
|
reg [16:0] audioTimer;
|
|
reg [16:0] ctsTimer;
|
|
reg [1:0] samplesHead;
|
|
reg [3:0] dataChannel0;
|
|
reg [3:0] dataChannel1;
|
|
reg [3:0] dataChannel2;
|
|
reg [23:0] packetHeader;
|
|
reg [55:0] subpacket[3:0];
|
|
reg [7:0] bchHdr;
|
|
reg [7:0] bchCode [3:0];
|
|
reg [4:0] dataOffset;
|
|
reg tercData;
|
|
reg [25:0] audioRAvgSum;
|
|
reg [25:0] audioLAvgSum;
|
|
reg [15:0] audioRAvg;
|
|
reg [15:0] audioLAvg;
|
|
reg [10:0] audioAvgCnt;
|
|
reg [15:0] counterX;
|
|
reg firstHSyncChange;
|
|
reg oddLine;
|
|
reg prevHSync;
|
|
reg prevBlank;
|
|
reg allowGeneration;
|
|
|
|
initial
|
|
begin
|
|
audioPacketHeader=0;
|
|
audioSubPacket[0]=0;
|
|
audioSubPacket[1]=0;
|
|
audioSubPacket[2]=0;
|
|
audioSubPacket[3]=0;
|
|
channelStatusIdx=0;
|
|
audioTimer=0;
|
|
samplesHead=0;
|
|
ctsTimer = 0;
|
|
dataChannel0=0;
|
|
dataChannel1=0;
|
|
dataChannel2=0;
|
|
packetHeader=0;
|
|
subpacket[0]=0;
|
|
subpacket[1]=0;
|
|
subpacket[2]=0;
|
|
subpacket[3]=0;
|
|
bchHdr=0;
|
|
bchCode[0]=0;
|
|
bchCode[1]=0;
|
|
bchCode[2]=0;
|
|
bchCode[3]=0;
|
|
dataOffset=0;
|
|
tercData=0;
|
|
oddLine=0;
|
|
counterX=0;
|
|
prevHSync = 0;
|
|
prevBlank = 0;
|
|
firstHSyncChange = 0;
|
|
allowGeneration = 0;
|
|
audioRAvg = 0;
|
|
audioLAvg = 0;
|
|
audioRAvgSum = 0;
|
|
audioLAvgSum = 0;
|
|
audioAvgCnt = 1;
|
|
end
|
|
|
|
function [7:0] ECCcode; // Cycles the error code generator
|
|
input [7:0] code;
|
|
input bita;
|
|
input passthroughData;
|
|
begin
|
|
ECCcode = (code<<1) ^ (((code[7]^bita) && passthroughData)?(1+(1<<6)+(1<<7)):0);
|
|
end
|
|
endfunction
|
|
|
|
task ECCu;
|
|
output outbit;
|
|
inout [7:0] code;
|
|
input bita;
|
|
input passthroughData;
|
|
begin
|
|
outbit <= passthroughData?bita:code[7];
|
|
code <= ECCcode(code, bita, passthroughData);
|
|
end
|
|
endtask
|
|
|
|
task ECC2u;
|
|
output outbita;
|
|
output outbitb;
|
|
inout [7:0] code;
|
|
input bita;
|
|
input bitb;
|
|
input passthroughData;
|
|
begin
|
|
outbita <= passthroughData?bita:code[7];
|
|
outbitb <= passthroughData?bitb:(code[6]^(((code[7]^bita) && passthroughData)?1'b1:1'b0));
|
|
code <= ECCcode(ECCcode(code, bita, passthroughData), bitb, passthroughData);
|
|
end
|
|
endtask
|
|
|
|
task SendPacket;
|
|
inout [32:0] pckHeader;
|
|
inout [55:0] pckData0;
|
|
inout [55:0] pckData1;
|
|
inout [55:0] pckData2;
|
|
inout [55:0] pckData3;
|
|
input firstPacket;
|
|
begin
|
|
dataChannel0[0]=i_hSync;
|
|
dataChannel0[1]=i_vSync;
|
|
dataChannel0[3]=(!firstPacket || dataOffset)?1'b1:1'b0;
|
|
ECCu(dataChannel0[2], bchHdr, pckHeader[0], dataOffset<24?1'b1:1'b0);
|
|
ECC2u(dataChannel1[0], dataChannel2[0], bchCode[0], pckData0[0], pckData0[1], dataOffset<28?1'b1:1'b0);
|
|
ECC2u(dataChannel1[1], dataChannel2[1], bchCode[1], pckData1[0], pckData1[1], dataOffset<28?1'b1:1'b0);
|
|
ECC2u(dataChannel1[2], dataChannel2[2], bchCode[2], pckData2[0], pckData2[1], dataOffset<28?1'b1:1'b0);
|
|
ECC2u(dataChannel1[3], dataChannel2[3], bchCode[3], pckData3[0], pckData3[1], dataOffset<28?1'b1:1'b0);
|
|
pckHeader<=pckHeader[23:1];
|
|
pckData0<=pckData0[55:2];
|
|
pckData1<=pckData1[55:2];
|
|
pckData2<=pckData2[55:2];
|
|
pckData3<=pckData3[55:2];
|
|
dataOffset<=dataOffset+5'b1;
|
|
end
|
|
endtask
|
|
|
|
task InfoGen;
|
|
inout [16:0] _timer;
|
|
begin
|
|
if (_timer >= CTS) begin
|
|
packetHeader<=24'h000001; // audio clock regeneration packet
|
|
subpacket[0]<=audioRegenPacket;
|
|
subpacket[1]<=audioRegenPacket;
|
|
subpacket[2]<=audioRegenPacket;
|
|
subpacket[3]<=audioRegenPacket;
|
|
_timer <= _timer - CTS + 1;
|
|
end else begin
|
|
if (!oddLine) begin
|
|
packetHeader<=24'h0D0282; // infoframe AVI packet
|
|
// Byte0: Checksum (256-(S%256))%256
|
|
// Byte1: 10 = 0(Y1:Y0=0 RGB)(A0=1 active format valid)(B1:B0=00 No bar info)(S1:S0=00 No scan info)
|
|
// Byte2: 19 = (C1:C0=0 No colorimetry)(M1:M0=1 4:3)(R3:R0=9 4:3 center)
|
|
// Byte3: 00 = 0(SC1:SC0=0 No scaling)
|
|
// Byte4: 00 = 0(VIC6:VIC0=0 custom resolution)
|
|
// Byte5: 00 = 0(PR5:PR0=0 No repeation)
|
|
subpacket[0]<=56'h00000000191046;
|
|
subpacket[1]<=56'h00000000000000;
|
|
end else begin
|
|
packetHeader<=24'h0A0184; // infoframe audio packet
|
|
// Byte0: Checksum (256-(S%256))%256
|
|
// Byte1: 11 = (CT3:0=1 PCM)0(CC2:0=1 2ch)
|
|
// Byte2: 00 = 000(SF2:0=0 As stream)(SS1:0=0 As stream)
|
|
// Byte3: 00 = LPCM doesn't use this
|
|
// Byte4-5: 00 Multichannel only (>2ch)
|
|
subpacket[0]<=56'h00000000001160;
|
|
subpacket[1]<=56'h00000000000000;
|
|
end
|
|
subpacket[2]<=56'h00000000000000;
|
|
subpacket[3]<=56'h00000000000000;
|
|
end
|
|
end
|
|
endtask
|
|
|
|
task AproximateAudio;
|
|
begin
|
|
audioLAvgSum <= audioLAvgSum + i_audioL;
|
|
audioRAvgSum <= audioRAvgSum + i_audioR;
|
|
audioLAvg <= audioLAvgSum/audioAvgCnt;
|
|
audioRAvg <= audioRAvgSum/audioAvgCnt;
|
|
audioAvgCnt <= audioAvgCnt + 1;
|
|
end
|
|
endtask
|
|
|
|
task AudioGen;
|
|
begin
|
|
// Buffer up an audio sample
|
|
// Don't add to the audio output if we're currently sending that packet though
|
|
if (!( allowGeneration && counterX >= 32 && counterX < 64)) begin
|
|
if (audioTimer>=`AUDIO_TIMER_LIMIT) begin
|
|
audioTimer<=audioTimer-`AUDIO_TIMER_LIMIT+`AUDIO_TIMER_ADDITION;
|
|
audioPacketHeader<=audioPacketHeader|24'h000002|((channelStatusIdx==0?24'h100100:24'h000100)<<samplesHead);
|
|
audioSubPacket[samplesHead]<=((audioLAvg<<8)|(audioRAvg<<32)
|
|
|((^audioLAvg)?56'h08000000000000:56'h0) // parity bit for left channel
|
|
|((^audioRAvg)?56'h80000000000000:56'h0)) // parity bit for right channel
|
|
^(channelStatus[channelStatusIdx]?56'hCC000000000000:56'h0); // And channel status bit and adjust parity
|
|
if (channelStatusIdx<191)
|
|
channelStatusIdx<=channelStatusIdx+8'd1;
|
|
else
|
|
channelStatusIdx<=0;
|
|
samplesHead<=samplesHead+2'd1;
|
|
audioLAvgSum <= 0;
|
|
audioRAvgSum <= 0;
|
|
audioAvgCnt <= 1;
|
|
end else begin
|
|
audioTimer<=audioTimer+`AUDIO_TIMER_ADDITION;
|
|
AproximateAudio();
|
|
end
|
|
end else begin
|
|
audioTimer<=audioTimer+`AUDIO_TIMER_ADDITION;
|
|
AproximateAudio();
|
|
samplesHead<=0;
|
|
end
|
|
end
|
|
endtask
|
|
|
|
task SendPackets;
|
|
inout dataEnable;
|
|
begin
|
|
if (counterX<32) begin
|
|
// Send first data packet (Infoframe or audio clock regen)
|
|
dataEnable<=1;
|
|
SendPacket(packetHeader, subpacket[0], subpacket[1], subpacket[2], subpacket[3], 1);
|
|
end else if (counterX<64) begin
|
|
// Send second data packet (audio data)
|
|
SendPacket(audioPacketHeader, audioSubPacket[0], audioSubPacket[1], audioSubPacket[2], audioSubPacket[3], 0);
|
|
end else begin
|
|
dataEnable<=0;
|
|
end
|
|
end
|
|
endtask
|
|
|
|
always @(posedge i_pixclk)
|
|
begin
|
|
|
|
AudioGen();
|
|
|
|
// Send 2 packets each line
|
|
if(allowGeneration) begin
|
|
SendPackets(tercData);
|
|
end else begin
|
|
tercData<=0;
|
|
end
|
|
|
|
ctsTimer <= ctsTimer + 1;
|
|
|
|
if((prevBlank == 0) && (i_blank == 1))
|
|
firstHSyncChange <= 1;
|
|
|
|
if((prevBlank == 1) && (i_blank == 0))
|
|
allowGeneration <= 0;
|
|
|
|
if(prevHSync != i_hSync) begin
|
|
if(firstHSyncChange) begin
|
|
InfoGen(ctsTimer);
|
|
oddLine <= ! oddLine;
|
|
counterX <= 0;
|
|
allowGeneration <= 1;
|
|
end else begin
|
|
counterX <= counterX + 1;
|
|
end
|
|
firstHSyncChange <= !firstHSyncChange;
|
|
end else
|
|
counterX <= counterX + 1;
|
|
|
|
prevBlank <= i_blank;
|
|
prevHSync <= i_hSync;
|
|
end
|
|
|
|
assign o_d0 = dataChannel0;
|
|
assign o_d1 = dataChannel1;
|
|
assign o_d2 = dataChannel2;
|
|
assign o_data = tercData;
|
|
|
|
endmodule
|