mirror of
https://github.com/PredatH0r/ChanSort.git
synced 2026-01-14 19:32:04 +01:00
c9fb32f40b
- Philips: fixed display of symbol rate and frequency (off by factor 1000 depending of list and DVB source) - Philips: fixed special characters in channel names (e.g. german umlauts) - Philips: "ServiceType" now only shows "TV" or "Radio". There is no information about HD/SD in the file.
808 lines
30 KiB
C#
808 lines
30 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Data;
|
|
using System.Data.SQLite;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using ChanSort.Api;
|
|
|
|
namespace ChanSort.Loader.Philips
|
|
{
|
|
/*
|
|
|
|
This loader handles the file format versions 1.x (*Table and *.dat files) and version 25.x-45.x (*Db.bin files)
|
|
|
|
channellib\CableDigSrvTable:
|
|
===========================
|
|
Channels in this file are not physically ordered by the program number and there is no linked list with prev/next indexes.
|
|
When editing a channel with the Philips Channel Editor, it only updates the progNr field (and overwrites all trailing bytes of the channel name with 0x00).
|
|
There is also the CablePresetTable file which is probably used for LCN. The Philips tool also updates the progNr in that file and uses it as is primary source
|
|
for the progNr. I don't know if there is a direct reference from the channel to the preset, hence this code uses the combination of ONID+TSID+SID to link the two.
|
|
|
|
s2channellib\service.dat:
|
|
========================
|
|
All observed files have a perfectly linear next/prev table. The Philips Channel Editor also keeps that list linear and physically reorders the channel records.
|
|
Also, all observed channel records have progNr either equal to the physical index + 1 or to 0xffff.
|
|
Each channel record with progNr 0xFFFF causes a gap in the progNr sequence.
|
|
It is unclear:
|
|
- if the next/prev list MUST be kept linear
|
|
- channel records MUST be physically ordered to be in-sync with the next/prev list
|
|
- channel records MUST be physically ordered by progNr (allowing 0xFFFF for gaps)
|
|
To be on the safe side, this code keeps the list linear, physically reorders the records to match the progNr.
|
|
Since we don't show deleted channels in the UI, we can't keep the gaps caused by them in the channel list. They will be appended at the end and the gaps closed.
|
|
|
|
When swapping satellite channels 1 and 2 with the Philips Channel Editor 6.62, it only updates a few fields and leaves the rest stale.
|
|
updated: SID, transponderIndex, channelName, providerName
|
|
This code here copies the whole record before updating the fields.
|
|
|
|
The favorite.dat file stores favorites as linked list which may support independent ordering from the main channel list.
|
|
The Philips editor even saves non-linear lists, but not in any particular order.
|
|
|
|
*/
|
|
class BinarySerializer : SerializerBase
|
|
{
|
|
private readonly IniFile ini;
|
|
private readonly List<string> dataFilePaths = new List<string>();
|
|
private readonly ChannelList dvbtChannels = new ChannelList(SignalSource.DvbT, "DVB-T");
|
|
private readonly ChannelList dvbcChannels = new ChannelList(SignalSource.DvbC, "DVB-C");
|
|
private readonly ChannelList satChannels = new ChannelList(SignalSource.DvbS, "DVB-S");
|
|
private ChanLstBin chanLstBin;
|
|
private readonly StringBuilder logMessages = new StringBuilder();
|
|
|
|
#region ctor()
|
|
public BinarySerializer(string inputFile) : base(inputFile)
|
|
{
|
|
this.Features.ChannelNameEdit = ChannelNameEditMode.None;
|
|
this.Features.CanSkipChannels = false;
|
|
this.Features.CanLockChannels = true;
|
|
this.Features.CanHideChannels = false;
|
|
this.Features.DeleteMode = DeleteMode.NotSupported;
|
|
this.Features.CanSaveAs = false;
|
|
this.Features.CanHaveGaps = false;
|
|
this.Features.SupportedFavorites = Favorites.A;
|
|
this.Features.SortedFavorites = false; // satellite favorites are stored in a separate file that may support independent sorting, but DVB C/T only have a flag
|
|
this.Features.AllowGapsInFavNumbers = false;
|
|
this.Features.CanEditFavListNames = false;
|
|
|
|
this.DataRoot.AddChannelList(this.dvbtChannels);
|
|
this.DataRoot.AddChannelList(this.dvbcChannels);
|
|
this.DataRoot.AddChannelList(this.satChannels);
|
|
|
|
foreach (var list in this.DataRoot.ChannelLists)
|
|
{
|
|
list.VisibleColumnFieldNames.Remove("Skip");
|
|
list.VisibleColumnFieldNames.Remove("ShortName");
|
|
list.VisibleColumnFieldNames.Remove("ServiceTypeName");
|
|
list.VisibleColumnFieldNames.Remove("Hidden");
|
|
list.VisibleColumnFieldNames.Remove("AudioPid");
|
|
list.VisibleColumnFieldNames.Remove("Encrypted");
|
|
}
|
|
|
|
foreach (var list in new[] {dvbcChannels, dvbtChannels})
|
|
{
|
|
list.VisibleColumnFieldNames.Remove("PcrPid");
|
|
list.VisibleColumnFieldNames.Remove("VideoPid");
|
|
list.VisibleColumnFieldNames.Remove("AudioPid");
|
|
list.VisibleColumnFieldNames.Remove("ChannelOrTransponder");
|
|
list.VisibleColumnFieldNames.Remove("Provider");
|
|
}
|
|
|
|
string iniFile = Assembly.GetExecutingAssembly().Location.Replace(".dll", ".ini");
|
|
this.ini = new IniFile(iniFile);
|
|
}
|
|
#endregion
|
|
|
|
#region Load()
|
|
public override void Load()
|
|
{
|
|
this.chanLstBin = new ChanLstBin();
|
|
this.chanLstBin.Load(this.FileName, msg => this.logMessages.AppendLine(msg));
|
|
this.dataFilePaths.Add(this.FileName);
|
|
|
|
if (chanLstBin.VersionMajor >= 25 && chanLstBin.VersionMajor <= 45) // need VC2010 Redist for the SQLite library
|
|
DepencencyChecker.AssertVc2010RedistPackageX86Installed();
|
|
|
|
var dir = Path.GetDirectoryName(this.FileName) ?? "";
|
|
var channellib = Path.Combine(dir, "channellib");
|
|
var s2channellib = Path.Combine(dir, "s2channellib");
|
|
|
|
if (chanLstBin.VersionMajor <= 11)
|
|
{
|
|
LoadDvbCT(dvbtChannels, Path.Combine(channellib, "AntennaDigSrvTable"), "CableDigSrvTable_entry");
|
|
LoadDvbCTPresets(dvbtChannels, Path.Combine(channellib, "AntennaPresetTable"));
|
|
LoadDvbCT(dvbcChannels, Path.Combine(channellib, "CableDigSrvTable"), "CableDigSrvTable_entry");
|
|
LoadDvbCTPresets(dvbcChannels, Path.Combine(channellib, "CablePresetTable"));
|
|
|
|
LoadDvbsSatellites(Path.Combine(s2channellib, "satellite.dat"));
|
|
LoadDvbsTransponders(Path.Combine(s2channellib, "tuneinfo.dat"));
|
|
LoadDvbS(satChannels, Path.Combine(s2channellib, "service.dat"), "service.dat_entry");
|
|
LoadDvbsFavorites(Path.Combine(s2channellib, "favorite.dat"));
|
|
var db_file_info = Path.Combine(s2channellib, "db_file_info.dat");
|
|
if (File.Exists(db_file_info))
|
|
this.dataFilePaths.Add(db_file_info);
|
|
}
|
|
else if (chanLstBin.VersionMajor >= 25 && chanLstBin.VersionMajor <= 45)
|
|
{
|
|
// version 25-45
|
|
LoadDvbCT(dvbtChannels, Path.Combine(channellib, "TerrestrialDb.bin"), "Map45_CableDb.bin_entry");
|
|
LoadDvbCT(dvbcChannels, Path.Combine(channellib, "CableDb.bin"), "Map45_CableDb.bin_entry");
|
|
LoadDvbS(satChannels, Path.Combine(s2channellib, "SatelliteDb.bin"), "Map45_SatelliteDb.bin_entry");
|
|
var tvDbFile = Path.Combine(dir, "tv.db");
|
|
if (File.Exists(tvDbFile))
|
|
this.dataFilePaths.Add(tvDbFile);
|
|
}
|
|
|
|
// for a proper ChanSort backup/restore with .bak files, the Philips _backup.dat files must also be included
|
|
foreach (var file in this.dataFilePaths.ToList())
|
|
{
|
|
if (file.Contains(".dat"))
|
|
this.dataFilePaths.Add(file.Replace(".dat", "_backup.dat"));
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
|
|
#region LoadDvbCT
|
|
private void LoadDvbCT(ChannelList list, string path, string mappingName)
|
|
{
|
|
if (!ReadAndValidateChannellibFile(path, out var data, out var recordSize, out var recordCount))
|
|
return;
|
|
|
|
var mapping = new DataMapping(this.ini.GetSection(mappingName));
|
|
mapping.SetDataPtr(data, chanLstBin.VersionMajor <= 11 ? 20 : 12);
|
|
|
|
for (int i = 0; i < recordCount; i++, mapping.BaseOffset += recordSize)
|
|
{
|
|
var progNr = mapping.GetWord("offProgNr");
|
|
|
|
var offChannelName = mapping.BaseOffset + mapping.GetConst("offName", 0);
|
|
var lenName = mapping.GetConst("lenName", 0);
|
|
for (int j = 0; j < lenName; j += 2)
|
|
{
|
|
if (data[offChannelName + j] == 0)
|
|
{
|
|
lenName = j;
|
|
break;
|
|
}
|
|
}
|
|
string channelName = Encoding.Unicode.GetString(data, offChannelName, lenName);
|
|
|
|
if (chanLstBin.VersionMajor <= 11)
|
|
{
|
|
var checksum = mapping.GetDword("offChecksum");
|
|
mapping.SetDword("offChecksum", 0);
|
|
var crc = FaultyCrc32(data, mapping.BaseOffset + mapping.GetConst("offChecksum", 0), recordSize);
|
|
if (crc != checksum)
|
|
throw new FileLoadException($"Invalid CRC in record {i} in {path}");
|
|
}
|
|
|
|
var ch = new Channel(list.SignalSource, i, progNr, channelName);
|
|
ch.Id = mapping.GetWord("offId"); // only relevant for ChannelMap45
|
|
ch.FreqInMhz = (decimal) mapping.GetWord("offFreqTimes16") / 16;
|
|
ch.OriginalNetworkId = mapping.GetWord("offOnid");
|
|
ch.TransportStreamId = mapping.GetWord("offTsid");
|
|
ch.ServiceId = mapping.GetWord("offSid");
|
|
ch.SymbolRate = (int)mapping.GetDword("offSymbolRate") / 1000;
|
|
ch.Lock = mapping.GetByte("offLocked") != 0;
|
|
ch.Favorites = mapping.GetByte("offIsFav") != 0 ? Favorites.A : 0;
|
|
if (ch.Favorites != 0)
|
|
ch.OldFavIndex[0] = ch.OldProgramNr;
|
|
this.DataRoot.AddChannel(list, ch);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region LoadDvbCTPresets
|
|
private void LoadDvbCTPresets(ChannelList list, string path)
|
|
{
|
|
if (!ReadAndValidateChannellibFile(path, out var data, out var recordSize, out var recordCount))
|
|
return;
|
|
|
|
// build a mapping of (onid,tsid,sid) => channel
|
|
var channelById = new Dictionary<ulong, Channel>();
|
|
foreach(var chan in list.Channels)
|
|
{
|
|
var ch = (Channel)chan;
|
|
var id = ((ulong)ch.OriginalNetworkId << 32) | ((ulong)ch.TransportStreamId << 16) | (uint)ch.ServiceId;
|
|
channelById[id] = ch;
|
|
}
|
|
|
|
// apply preset progNr (LCN?) to the channel and remember the preset index for it
|
|
var mapping = new DataMapping(this.ini.GetSection("CablePresetTable_entry"));
|
|
mapping.SetDataPtr(data, 20);
|
|
for (int i = 0; i < recordCount; i++, mapping.BaseOffset += recordSize)
|
|
{
|
|
var onid = mapping.GetWord("offOnid");
|
|
var tsid = mapping.GetWord("offTsid");
|
|
var sid = mapping.GetWord("offSid");
|
|
var id = ((ulong)onid << 32) | ((ulong)tsid << 16) | sid;
|
|
if (!channelById.TryGetValue(id, out var ch))
|
|
continue;
|
|
|
|
ch.PresetTableIndex = i;
|
|
var progNr = mapping.GetWord("offProgNr");
|
|
if (progNr != 0 && progNr != 0xFFFF)
|
|
ch.OldProgramNr = progNr;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region ReadAndValidateChannellibFile
|
|
private bool ReadAndValidateChannellibFile(string path, out byte[] data, out int recordSize, out int recordCount)
|
|
{
|
|
data = null;
|
|
recordSize = 0;
|
|
recordCount = 0;
|
|
|
|
if (!File.Exists(path))
|
|
return false;
|
|
|
|
data = File.ReadAllBytes(path);
|
|
if (chanLstBin.VersionMajor <= 11)
|
|
{
|
|
if (data.Length < 20)
|
|
return false;
|
|
|
|
recordSize = BitConverter.ToInt32(data, 8);
|
|
recordCount = BitConverter.ToInt32(data, 12);
|
|
if (data.Length != 20 + recordCount * recordSize)
|
|
throw new FileLoadException("Unsupported file content: " + path);
|
|
}
|
|
else
|
|
{
|
|
if (data.Length < 12)
|
|
return false;
|
|
|
|
recordSize = 156; // Map45
|
|
recordCount = BitConverter.ToInt32(data, 8);
|
|
if (data.Length != 12 + recordCount * recordSize)
|
|
throw new FileLoadException("Unsupported file content: " + path);
|
|
}
|
|
|
|
|
|
this.dataFilePaths.Add(path);
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region LoadDvbsSatellites()
|
|
private void LoadDvbsSatellites(string path)
|
|
{
|
|
if (!File.Exists(path))
|
|
return;
|
|
var data = File.ReadAllBytes(path);
|
|
if (data.Length < 4)
|
|
return;
|
|
var checksum = BitConverter.ToUInt32(data, data.Length - 4);
|
|
var crc = ~Crc32.Reversed.CalcCrc32(data, 0, data.Length - 4);
|
|
if (checksum != crc)
|
|
return;
|
|
int recordSize = BitConverter.ToInt32(data, 4);
|
|
int recordCount = BitConverter.ToInt32(data, 8);
|
|
|
|
// 12 byte header, table of (next, prev) transponder, records, crc32
|
|
if (data.Length != 12 + recordCount * 4 + recordCount * recordSize + 4)
|
|
return;
|
|
|
|
var baseOffset = 12 + recordCount * 4;
|
|
for (int i = 0; i < recordCount; i++, baseOffset += recordSize)
|
|
{
|
|
if (data[baseOffset + 0] == 0)
|
|
continue;
|
|
|
|
var s = new Satellite(i);
|
|
var pos = (sbyte)data[baseOffset + 8];
|
|
s.OrbitalPosition = pos < 0 ? -pos + "W" : pos + "E";
|
|
s.Name = this.DefaultEncoding.GetString(data, baseOffset + 16, 16).TrimGarbage();
|
|
|
|
this.DataRoot.AddSatellite(s);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region LoadDvbsTransponders
|
|
private void LoadDvbsTransponders(string path)
|
|
{
|
|
if (!File.Exists(path))
|
|
return;
|
|
var data = File.ReadAllBytes(path);
|
|
if (data.Length < 4)
|
|
return;
|
|
var checksum = BitConverter.ToUInt32(data, data.Length - 4);
|
|
var crc = ~Crc32.Reversed.CalcCrc32(data, 0, data.Length - 4);
|
|
if (checksum != crc)
|
|
return;
|
|
int recordSize = BitConverter.ToInt32(data, 4);
|
|
int recordCount = BitConverter.ToInt32(data, 8);
|
|
|
|
// 12 byte header, table of (next, prev) transponder, records, crc32
|
|
if (data.Length != 12 + recordCount * 4 + recordCount * recordSize + 4)
|
|
return;
|
|
|
|
var baseOffset = 12 + recordCount * 4;
|
|
for (int i = 0; i < recordCount; i++, baseOffset += recordSize)
|
|
{
|
|
var symRate = BitConverter.ToUInt16(data, baseOffset + 0);
|
|
if (symRate == 0xFFFF)
|
|
continue;
|
|
|
|
var tsid = BitConverter.ToUInt16(data, baseOffset + 16);
|
|
var onid = BitConverter.ToUInt16(data, baseOffset + 18);
|
|
|
|
var t = new Transponder(i);
|
|
t.SymbolRate = symRate;
|
|
t.FrequencyInMhz = BitConverter.ToUInt16(data, baseOffset + 2);
|
|
var satIndex = data[baseOffset + 6] >> 4; // guesswork
|
|
t.Satellite = DataRoot.Satellites.TryGet(satIndex);
|
|
t.TransportStreamId = tsid;
|
|
t.OriginalNetworkId = onid;
|
|
this.DataRoot.AddTransponder(t.Satellite, t);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region LoadDvbS
|
|
private void LoadDvbS(ChannelList list, string path, string mappingName)
|
|
{
|
|
if (!File.Exists(path))
|
|
return;
|
|
|
|
var data = File.ReadAllBytes(path);
|
|
if (data.Length < 12)
|
|
return;
|
|
|
|
var version = chanLstBin.VersionMajor;
|
|
|
|
if (version <= 11)
|
|
{
|
|
var checksum = BitConverter.ToUInt32(data, data.Length - 4);
|
|
|
|
var crcObj = new Crc32(false, Crc32.NormalPoly);
|
|
var crc = ~crcObj.CalcCrc32(data, 0, data.Length - 4);
|
|
if (checksum != crc)
|
|
throw new FileLoadException("Invalid CRC32 in " + path);
|
|
}
|
|
|
|
|
|
int recordSize = BitConverter.ToInt32(data, 4);
|
|
int recordCount = BitConverter.ToInt32(data, 8);
|
|
if (recordSize == 0 && version != 1)
|
|
recordSize = recordCount == 0 ? 0 : (data.Length - 12) / recordCount;
|
|
|
|
if (chanLstBin.VersionMajor <= 11)
|
|
{
|
|
// 12 bytes header, then a "next/prev" table, then the service records, then a CRC32
|
|
// the "next/prev" table is a ring-list, every entry consists of 2 ushorts with the next and previous channel, wrapping around on the ends
|
|
if (data.Length != 12 + recordCount * 4 + recordCount * recordSize + 4)
|
|
throw new FileLoadException("Unsupported file content: " + path);
|
|
}
|
|
|
|
this.dataFilePaths.Add(path);
|
|
|
|
var dvbStringDecoder = new DvbStringDecoder(this.DefaultEncoding);
|
|
|
|
var mapping = new DataMapping(this.ini.GetSection(mappingName));
|
|
mapping.SetDataPtr(data, 12 + (chanLstBin.VersionMajor <= 11 ? recordCount * 4 : 0));
|
|
for (int i = 0; i < recordCount; i++, mapping.BaseOffset += recordSize)
|
|
{
|
|
var ch = LoadDvbsChannel(list, mapping, i, dvbStringDecoder);
|
|
this.DataRoot.AddChannel(list, ch);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region LoadDvbsChannel
|
|
private ChannelInfo LoadDvbsChannel(ChannelList list, DataMapping mapping, int recordIndex, DvbStringDecoder dvbStringDecoder)
|
|
{
|
|
var transponderId = mapping.GetWord("offTransponderIndex");
|
|
var progNr = mapping.GetWord("offProgNr");
|
|
var ch = new Channel(list.SignalSource, recordIndex, progNr, "");
|
|
|
|
// deleted channels must be kept in the list because their records must also be physically reordered when saving the list
|
|
if (progNr == 0xFFFF || transponderId == 0xFFFF)
|
|
{
|
|
ch.IsDeleted = true;
|
|
ch.OldProgramNr = -1;
|
|
return ch;
|
|
}
|
|
|
|
// onid, tsid, pcrpid and vpid can be 0 in some lists
|
|
ch.PcrPid = mapping.GetWord("offPcrPid") & mapping.GetMask("maskPcrPid");
|
|
ch.Lock = mapping.GetFlag("Locked");
|
|
ch.OriginalNetworkId = mapping.GetWord("OffOnid");
|
|
ch.TransportStreamId = mapping.GetWord("offTsid");
|
|
ch.ServiceId = mapping.GetWord("offSid");
|
|
ch.VideoPid = mapping.GetWord("offVpid") & mapping.GetMask("maskVpid");
|
|
ch.Favorites = mapping.GetFlag("IsFav") ? Favorites.A : 0;
|
|
ch.OldProgramNr = progNr;
|
|
ch.Id = mapping.GetWord("offId"); // relevant for ChannelMap45
|
|
|
|
if (chanLstBin.VersionMajor <= 11)
|
|
{
|
|
// the 0x1F as the first byte of the channel name is likely the DVB encoding indicator for UTF-8. So we use the DvbStringDecoder here
|
|
dvbStringDecoder.GetChannelNames(mapping.Data, mapping.BaseOffset + mapping.GetConst("offName", 0), mapping.GetConst("lenName", 0), out var longName, out var shortName);
|
|
ch.Name = longName;
|
|
ch.ShortName = shortName;
|
|
}
|
|
else
|
|
{
|
|
ch.Name = Encoding.Unicode.GetString(mapping.Data, mapping.BaseOffset + mapping.GetConst("offName", 0), mapping.GetConst("lenName", 0)).TrimEnd('\0');
|
|
ch.FreqInMhz = mapping.GetWord("offFreq");
|
|
ch.SymbolRate = (int)(mapping.GetDword("offSymbolRate") / 1000);
|
|
}
|
|
|
|
dvbStringDecoder.GetChannelNames(mapping.Data, mapping.BaseOffset + mapping.GetConst("offProvider", 0), mapping.GetConst("lenProvider", 0), out var provider, out _);
|
|
ch.Provider = provider;
|
|
|
|
// copy values from the satellite/transponder tables to the channel
|
|
if (this.DataRoot.Transponder.TryGetValue(transponderId, out var t))
|
|
{
|
|
ch.Transponder = t;
|
|
ch.FreqInMhz = t.FrequencyInMhz;
|
|
ch.SymbolRate = t.SymbolRate;
|
|
ch.SatPosition = t.Satellite?.OrbitalPosition;
|
|
ch.Satellite = t.Satellite?.Name;
|
|
if (t.OriginalNetworkId != 0)
|
|
ch.OriginalNetworkId = t.OriginalNetworkId;
|
|
if (t.TransportStreamId != 0)
|
|
ch.TransportStreamId = t.TransportStreamId;
|
|
}
|
|
|
|
return ch;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region LoadDvbsFavorites
|
|
private void LoadDvbsFavorites(string path)
|
|
{
|
|
if (!File.Exists(path))
|
|
return;
|
|
var data = File.ReadAllBytes(path);
|
|
if (data.Length < 4)
|
|
return;
|
|
var checksum = BitConverter.ToUInt32(data, data.Length - 4);
|
|
var crc = ~Crc32.Reversed.CalcCrc32(data, 0, data.Length - 4);
|
|
if (checksum != crc)
|
|
return;
|
|
|
|
int dataSize = BitConverter.ToInt32(data, 0);
|
|
var recordSize = 4;
|
|
var recordCount = (dataSize - 4) / recordSize;
|
|
|
|
// 4 byte header, data, crc32
|
|
if (data.Length != 4 + dataSize + 4)
|
|
return;
|
|
|
|
this.dataFilePaths.Add(path);
|
|
|
|
int firstFavIndex = BitConverter.ToInt16(data, 4);
|
|
int favCount = BitConverter.ToInt16(data, 6);
|
|
if (favCount > recordCount || firstFavIndex < 0 || firstFavIndex >= recordCount)
|
|
return;
|
|
|
|
var baseOffset = 8;
|
|
for (int i = 0, curFav = firstFavIndex; i < favCount; i++)
|
|
{
|
|
this.satChannels.Channels[curFav].SetOldPosition(1, i + 1);
|
|
curFav = BitConverter.ToInt16(data, baseOffset + curFav * 4 + 2);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
|
|
#region GetDataFilePaths
|
|
|
|
/// <summary>
|
|
/// List of files for backup/restore
|
|
/// </summary>
|
|
public override IEnumerable<string> GetDataFilePaths() => this.dataFilePaths;
|
|
#endregion
|
|
|
|
|
|
#region Save()
|
|
public override void Save(string tvOutputFile)
|
|
{
|
|
var dir = Path.GetDirectoryName(this.FileName) ?? "";
|
|
var channellib = Path.Combine(dir, "channellib");
|
|
var s2channellib = Path.Combine(dir, "s2channellib");
|
|
|
|
if (chanLstBin.VersionMajor <= 11)
|
|
{
|
|
SaveDvbCTChannels(this.dvbtChannels, Path.Combine(channellib, "AntennaDigSrvTable"));
|
|
SaveDvbCTPresets(this.dvbtChannels, Path.Combine(channellib, "AntennaPresetTable"));
|
|
SaveDvbCTChannels(this.dvbcChannels, Path.Combine(channellib, "CableDigSrvTable"));
|
|
SaveDvbCTPresets(this.dvbcChannels, Path.Combine(channellib, "CablePresetTable"));
|
|
|
|
SaveDvbsChannels(Path.Combine(s2channellib, "service.dat"));
|
|
SaveDvbsFavorites(Path.Combine(s2channellib, "favorite.dat"));
|
|
SaveDvbsDbFileInfo(Path.Combine(s2channellib, "db_file_info.dat"));
|
|
}
|
|
else if (chanLstBin.VersionMajor >= 25 && chanLstBin.VersionMajor <= 45)
|
|
{
|
|
SaveDvbCTChannels(this.dvbtChannels, Path.Combine(channellib, "TerrestrialDb.bin"));
|
|
SaveDvbCTChannels(this.dvbcChannels, Path.Combine(channellib, "CableDb.bin"));
|
|
SaveDvbsChannels(Path.Combine(s2channellib, "SatelliteDb.bin"));
|
|
|
|
UpdateChannelMap45TvDb();
|
|
}
|
|
|
|
this.chanLstBin.Save(this.FileName);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region SaveDvbCTChannels
|
|
private void SaveDvbCTChannels(ChannelList list, string path)
|
|
{
|
|
if (!ReadAndValidateChannellibFile(path, out var data, out var recordSize, out _))
|
|
return;
|
|
|
|
int baseOffset;
|
|
DataMapping mapping;
|
|
|
|
if (chanLstBin.VersionMajor <= 11)
|
|
{
|
|
mapping = new DataMapping(this.ini.GetSection("CableDigSrvTable_entry"));
|
|
baseOffset = 20;
|
|
}
|
|
else
|
|
{
|
|
mapping = new DataMapping(this.ini.GetSection("Map45_CableDb.bin_entry"));
|
|
baseOffset = 12;
|
|
}
|
|
mapping.SetDataPtr(data, baseOffset);
|
|
foreach (var ch in list.Channels)
|
|
{
|
|
if (ch.IsProxy) continue;
|
|
mapping.BaseOffset = baseOffset + (int)ch.RecordIndex * recordSize;
|
|
mapping.SetWord("offProgNr", ch.NewProgramNr);
|
|
mapping.SetByte("offLocked", ch.Lock ? 1 : 0);
|
|
mapping.SetByte("offIsFav", ch.Favorites == 0 ? 0 : 1);
|
|
|
|
if (chanLstBin.VersionMajor <= 11)
|
|
{
|
|
mapping.SetDword("offChecksum", 0);
|
|
var crc = FaultyCrc32(data, mapping.BaseOffset, recordSize);
|
|
mapping.SetDword("offChecksum", crc);
|
|
}
|
|
else if (chanLstBin.VersionMajor >= 25 && chanLstBin.VersionMajor <= 45)
|
|
{
|
|
mapping.SetWord("offServiceEdit", 1);
|
|
}
|
|
}
|
|
|
|
File.WriteAllBytes(path, data);
|
|
}
|
|
#endregion
|
|
|
|
#region SaveDvbCTPresets
|
|
private void SaveDvbCTPresets(ChannelList list, string path)
|
|
{
|
|
if (!ReadAndValidateChannellibFile(path, out var data, out var recordSize, out _))
|
|
return;
|
|
|
|
var mapping = new DataMapping(this.ini.GetSection("CablePresetTable_entry"));
|
|
mapping.SetDataPtr(data, 20);
|
|
|
|
|
|
// update the preset records with new channel numbers
|
|
foreach (var chan in list.Channels)
|
|
{
|
|
if (!(chan is Channel ch) || ch.PresetTableIndex < 0)
|
|
continue;
|
|
mapping.BaseOffset = 20 + ch.PresetTableIndex * recordSize;
|
|
mapping.SetWord("offProgNr", ch.NewProgramNr);
|
|
|
|
mapping.SetDword("offChecksum", 0);
|
|
var crc = FaultyCrc32(data, mapping.BaseOffset, recordSize);
|
|
mapping.SetDword("offChecksum", crc);
|
|
}
|
|
|
|
File.WriteAllBytes(path, data);
|
|
}
|
|
#endregion
|
|
|
|
#region SaveDvbsChannels
|
|
private void SaveDvbsChannels(string path)
|
|
{
|
|
var orig = File.ReadAllBytes(path);
|
|
|
|
// create a new array for the modified data, copying the header and next/prev table
|
|
var data = new byte[orig.Length];
|
|
|
|
int recordCount = BitConverter.ToInt32(orig, 8);
|
|
int recordSize;
|
|
int baseOffset;
|
|
DataMapping mapping;
|
|
|
|
if (chanLstBin.VersionMajor <= 11)
|
|
{
|
|
recordSize = BitConverter.ToInt32(orig, 4);
|
|
baseOffset = 12 + recordCount * 4;
|
|
mapping = new DataMapping(this.ini.GetSection("service.dat_entry"));
|
|
}
|
|
else
|
|
{
|
|
recordSize = recordCount == 0 ? 0 : (orig.Length - 12) / recordCount;
|
|
baseOffset = 12;
|
|
mapping = new DataMapping(this.ini.GetSection("Map45_SatelliteDb.bin_entry"));
|
|
}
|
|
|
|
if (recordCount == 0)
|
|
return;
|
|
|
|
Array.Copy(orig, data, baseOffset);
|
|
mapping.SetDataPtr(data, baseOffset);
|
|
|
|
// copy physical records to bring them in the new order and update fields like progNr
|
|
// this way the linked next/prev list remains in-sync with the channel order
|
|
int i = 0;
|
|
foreach (var ch in this.satChannels.Channels.OrderBy(c => c.NewProgramNr <= 0 ? int.MaxValue : c.NewProgramNr).ThenBy(c => c.OldProgramNr))
|
|
{
|
|
mapping.BaseOffset = baseOffset + i * recordSize;
|
|
Array.Copy(orig, baseOffset + (int)ch.RecordIndex * recordSize, data, mapping.BaseOffset, recordSize);
|
|
if (ch.IsDeleted)
|
|
{
|
|
mapping.SetWord("offSid", 0xFFFF);
|
|
mapping.SetWord("offTransponderIndex", 0xFFFF);
|
|
mapping.SetWord("offProgNr", 0xFFFF);
|
|
}
|
|
else
|
|
{
|
|
mapping.SetWord("offProgNr", ch.NewProgramNr);
|
|
mapping.SetFlag("IsFav", ch.Favorites != 0);
|
|
mapping.SetFlag("Locked", ch.Lock);
|
|
mapping.SetWord("offServiceEdit", 1);
|
|
}
|
|
|
|
ch.RecordIndex = i++; // required so that subsequent saves don't reshuffle the records
|
|
}
|
|
|
|
if (chanLstBin.VersionMajor <= 11)
|
|
{
|
|
var crc32 = ~Crc32.Reversed.CalcCrc32(data, 0, data.Length - 4);
|
|
data.SetInt32(data.Length - 4, (int) crc32);
|
|
|
|
var backupFile = path.Replace(".dat", "_backup.dat");
|
|
File.WriteAllBytes(backupFile, data);
|
|
}
|
|
|
|
File.WriteAllBytes(path, data);
|
|
}
|
|
#endregion
|
|
|
|
#region SaveDvbsFavorites
|
|
private void SaveDvbsFavorites(string path)
|
|
{
|
|
var data = File.ReadAllBytes(path);
|
|
|
|
int dataSize = BitConverter.ToInt32(data, 0);
|
|
var recordSize = 4;
|
|
var recordCount = (dataSize - 4) / recordSize;
|
|
|
|
var favList = this.satChannels.Channels.Where(c => c.FavIndex[0] != -1).OrderBy(c => c.FavIndex[0]).ToList();
|
|
var favCount = favList.Count;
|
|
var firstFavIndex = favCount == 0 ? -1 : (int)favList[0].RecordIndex;
|
|
data.SetInt16(4, firstFavIndex);
|
|
data.SetInt16(6, favCount);
|
|
data.MemSet(8, 0xFF, recordCount * 4);
|
|
if (favCount > 0)
|
|
{
|
|
var prevFav = (int) favList[favList.Count - 1].RecordIndex;
|
|
var curFav = firstFavIndex;
|
|
var nextFav = (int) favList[1 % favCount].RecordIndex;
|
|
for (int i = 0; i < favCount; i++)
|
|
{
|
|
var ch = favList[i];
|
|
var off = 8 + (int) ch.RecordIndex * 4;
|
|
data.SetInt16(off + 0, prevFav);
|
|
data.SetInt16(off + 2, nextFav);
|
|
prevFav = curFav;
|
|
curFav = nextFav;
|
|
nextFav = (int) favList[(i + 2) % favCount].RecordIndex;
|
|
}
|
|
}
|
|
|
|
var crc32 = ~Crc32.Reversed.CalcCrc32(data, 0, data.Length - 4);
|
|
data.SetInt32(data.Length - 4, (int)crc32);
|
|
File.WriteAllBytes(path, data);
|
|
|
|
var backupFile = path.Replace(".dat", "_backup.dat");
|
|
File.WriteAllBytes(backupFile, data);
|
|
}
|
|
#endregion
|
|
|
|
#region SaveDvbsDbFileInfo
|
|
private void SaveDvbsDbFileInfo(string path)
|
|
{
|
|
var data = File.ReadAllBytes(path);
|
|
// the ushort at offset 10 is incremented by 4 every time a change is made to the list (maybe the lower 2 bits of that fields are used for something else)
|
|
var offset = 10;
|
|
data.SetInt16(offset,data.GetInt16(offset) + 4);
|
|
|
|
var crc32 = ~Crc32.Reversed.CalcCrc32(data, 0, data.Length - 4);
|
|
data.SetInt32(data.Length - 4, (int)crc32);
|
|
File.WriteAllBytes(path, data);
|
|
|
|
var backupFile = path.Replace(".dat", "_backup.dat");
|
|
File.WriteAllBytes(backupFile, data);
|
|
}
|
|
#endregion
|
|
|
|
#region UpdateChannelMap45TvDb()
|
|
private void UpdateChannelMap45TvDb()
|
|
{
|
|
var tvDb = Path.Combine(Path.GetDirectoryName(this.FileName) ?? "", "tv.db");
|
|
if (!File.Exists(tvDb))
|
|
return;
|
|
|
|
using var conn = new SQLiteConnection($"Data Source={tvDb}");
|
|
conn.Open();
|
|
using var trans = conn.BeginTransaction();
|
|
using var cmd = conn.CreateCommand();
|
|
cmd.CommandText = "update channels set display_number=@prNum, display_name=@name, browsable=@browsable, locked=@locked where _id=@id";
|
|
cmd.Parameters.Clear();
|
|
cmd.Parameters.Add(new SQLiteParameter("@id", DbType.Int32));
|
|
cmd.Parameters.Add(new SQLiteParameter("@prNum", DbType.Int32));
|
|
cmd.Parameters.Add(new SQLiteParameter("@name", DbType.String));
|
|
cmd.Parameters.Add(new SQLiteParameter("@browsable", DbType.Int32));
|
|
cmd.Parameters.Add(new SQLiteParameter("@locked", DbType.Int32));
|
|
cmd.Prepare();
|
|
foreach (var list in this.DataRoot.ChannelLists)
|
|
{
|
|
foreach (var chan in list.Channels)
|
|
{
|
|
if (!(chan is Channel ch))
|
|
continue;
|
|
cmd.Parameters["@id"].Value = ch.Id;
|
|
cmd.Parameters["@prNum"].Value = ch.NewProgramNr;
|
|
cmd.Parameters["@name"].Value = ch.Name;
|
|
cmd.Parameters["@browsable"].Value = ch.Skip ? 0 : 1;
|
|
cmd.Parameters["@locked"].Value = ch.Lock ? 1 : 0;
|
|
|
|
var res = cmd.ExecuteNonQuery();
|
|
if (res == 0)
|
|
this.logMessages.AppendFormat($"Could not update record with id {ch.Id} in tv.db service table");
|
|
}
|
|
}
|
|
trans.Commit();
|
|
conn.Close();
|
|
}
|
|
#endregion
|
|
|
|
|
|
#region FaultyCrc32
|
|
public static uint FaultyCrc32(byte[] bytes, int start, int count)
|
|
{
|
|
var crc = 0xFFFFFFFF;
|
|
var off = start;
|
|
for (int i = 0; i < count; i++, off++)
|
|
{
|
|
var b = bytes[off];
|
|
for (int j = 0; j < 8; j++)
|
|
{
|
|
crc <<= 1;
|
|
var b1 = (uint)b >> 7;
|
|
var b2 = crc >> 31;
|
|
if (b1 != b2)
|
|
crc ^= 0x04C11DB7;
|
|
b <<= 1;
|
|
}
|
|
}
|
|
|
|
return ~crc;
|
|
}
|
|
#endregion
|
|
|
|
|
|
public override string GetFileInformation()
|
|
{
|
|
return base.GetFileInformation() + this.logMessages.Replace("\n", "\r\n");
|
|
}
|
|
}
|
|
}
|