ham-ref/satdump
1
0
Fork 0
mirror of https://github.com/SatDump/SatDump synced 2026-08-13 17:47:30 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions
satdump/plugins/xrit_support/DecompWT/T4Codes.cpp

373 lines
11 KiB
C++
Raw Permalink Normal View History

New xRIT files system - can be loaded as products now
2025-07-27 17:13:13 +02:00
/*
* Copyright 2011-2019, European Organisation for the Exploitation of Meteorological Satellites (EUMETSAT)
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
//:Ignore
/////////////////////////////////////////////////////////////
//
// FileName: T4Codes.cpp
//
// Date Created: 19/3/1998
//
// Author: Xavier Neyt
//
//
// Description: CCITT T4/G3 codes classes.
//
// Last Modified: $Dmae: 1998/11/24 10:27:30 $
//
// RCS ID: $Id: T4Codes.cpp,v 1.15 1998/11/24 10:27:30 xne Exp $
//
// Revision 1.8 1998/07/07 11:34:53 xne
// Updated include paths.
//
// Revision 1.7 1998/07/06 20:13:41 xne
// Made the necessary changes to comply with the new directory structure.
//
// Revision 1.6 1998/06/27 17:09:43 xne
// Modified namespace names MSI->DISE and RMA->COMP
//
// Revision 1.5 1998/06/19 17:26:08 xne
// inlined most member functions
//
// Revision 1.4 1998/04/14 21:59:14 xne
// Enabled namespace COMP
// Removed all global "using namespace XXX"
// Introduced new (14/4/98) version of the CDataField classes
// Introduced new (14/4/98) version of Compress.h
// Added some comments
//
// Revision 1.3 1998/04/09 20:24:46 xne
// Cosmetic changes
//
//////////////////////////////////////////////////////////////
//:End Ignore
#include <iostream>
#include "ErrorHandling.h"
#include "RMAErrorHandling.h"
#include "T4Codes.h"
namespace COMP
{
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void CT4Decodes::FillWhiteHashTable(oneCode *i_XxxWhiteCodes, short i_nElem)
{
COMP_TRYTHIS
short i = 0;
short idx = 0;
for (i = 0; i < i_nElem; i++)
{
idx = GetWhiteIndex(i_XxxWhiteCodes[i].GetCode(),
i_XxxWhiteCodes[i].GetLength());
//#ifdef _DEBUG // closed hash table->entry should be empty
Assert(m_WhiteHashTable[idx].GetCode() == -1, Util::CParamException());
//#endif
m_WhiteHashTable[idx] = i_XxxWhiteCodes[i];
}
COMP_CATCHTHIS
}
//-----------------------------------------------------------------------
void CT4Decodes::FillBlackHashTable(oneCode *i_XxxBlackCodes, short i_nElem)
{
COMP_TRYTHIS
short i = 0;
short idx = 0;
for (i = 0; i < i_nElem; i++)
{
idx = GetBlackIndex(i_XxxBlackCodes[i].GetCode(),
i_XxxBlackCodes[i].GetLength());
//#ifdef _DEBUG // closed hash table->entry should be empty
Assert(m_BlackHashTable[idx].GetCode() == -1, Util::CParamException());
//#endif
m_BlackHashTable[idx] = i_XxxBlackCodes[i];
}
COMP_CATCHTHIS
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void CT4Codes::TermWhiteInit(short i_count,
short i_code,
short i_length)
{
COMP_TRYTHIS
TermWhiteCodes[i_count](oneCode::e_TermWhite,
i_code,
i_length,
i_count);
COMP_CATCHTHIS
}
//-----------------------------------------------------------------------
void CT4Codes::TermBlackInit(short i_count,
short i_code,
short i_length)
{
COMP_TRYTHIS
TermBlackCodes[i_count](oneCode::e_TermBlack,
i_code,
i_length,
i_count);
COMP_CATCHTHIS
}
//-----------------------------------------------------------------------
void CT4Codes::MarkUpWhiteInit(short i_count,
short i_code,
short i_length)
{
COMP_TRYTHIS
short cnt = i_count / 64 - 1;
MarkUpWhiteCodes[cnt](oneCode::e_MarkUpWhite,
i_code,
i_length,
i_count);
COMP_CATCHTHIS
}
//-----------------------------------------------------------------------
void CT4Codes::MarkUpBlackInit(short i_count,
short i_code,
short i_length)
{
COMP_TRYTHIS
short cnt = i_count / 64 - 1;
MarkUpBlackCodes[cnt](oneCode::e_MarkUpBlack,
i_code,
i_length,
i_count);
COMP_CATCHTHIS
}
//-----------------------------------------------------------------------
void CT4Codes::MarkUpAddInit(short i_count,
short i_code,
short i_length)
{
COMP_TRYTHIS
short cnt = (i_count - 1792) / 64;
MarkUpAddCodes[cnt](oneCode::e_MarkUpAdd,
i_code,
i_length,
i_count);
COMP_CATCHTHIS
}
//-----------------------------------------------------------------------
CT4Codes::CT4Codes()
{
COMP_TRYTHIS
//-------------------------------------------------------------------
TermWhiteInit(0, 0x35, 8);
TermWhiteInit(1, 0x7, 6);
TermWhiteInit(2, 0x7, 4);
TermWhiteInit(3, 0x8, 4);
TermWhiteInit(4, 0xb, 4);
TermWhiteInit(5, 0xc, 4);
TermWhiteInit(6, 0xe, 4);
TermWhiteInit(7, 0xf, 4);
TermWhiteInit(8, 0x13, 5);
TermWhiteInit(9, 0x14, 5);
TermWhiteInit(10, 0x7, 5);
TermWhiteInit(11, 0x8, 5);
TermWhiteInit(12, 0x8, 6);
TermWhiteInit(13, 0x3, 6);
TermWhiteInit(14, 0x34, 6);
TermWhiteInit(15, 0x35, 6);
TermWhiteInit(16, 0x2a, 6);
TermWhiteInit(17, 0x2b, 6);
TermWhiteInit(18, 0x27, 7);
TermWhiteInit(19, 0xc, 7);
TermWhiteInit(20, 0x8, 7);
TermWhiteInit(21, 0x17, 7);
TermWhiteInit(22, 0x3, 7);
TermWhiteInit(23, 0x4, 7);
TermWhiteInit(24, 0x28, 7);
TermWhiteInit(25, 0x2b, 7);
TermWhiteInit(26, 0x13, 7);
TermWhiteInit(27, 0x24, 7);
TermWhiteInit(28, 0x18, 7);
TermWhiteInit(29, 0x2, 8);
TermWhiteInit(30, 0x3, 8);
TermWhiteInit(31, 0x1a, 8);
TermWhiteInit(32, 0x1b, 8);
TermWhiteInit(33, 0x12, 8);
TermWhiteInit(34, 0x13, 8);
TermWhiteInit(35, 0x14, 8);
TermWhiteInit(36, 0x15, 8);
TermWhiteInit(37, 0x16, 8);
TermWhiteInit(38, 0x17, 8);
TermWhiteInit(39, 0x28, 8);
TermWhiteInit(40, 0x29, 8);
TermWhiteInit(41, 0x2a, 8);
TermWhiteInit(42, 0x2b, 8);
TermWhiteInit(43, 0x2c, 8);
TermWhiteInit(44, 0x2d, 8);
TermWhiteInit(45, 0x4, 8);
TermWhiteInit(46, 0x5, 8);
TermWhiteInit(47, 0xa, 8);
TermWhiteInit(48, 0xb, 8);
TermWhiteInit(49, 0x52, 8);
TermWhiteInit(50, 0x53, 8);
TermWhiteInit(51, 0x54, 8);
TermWhiteInit(52, 0x55, 8);
TermWhiteInit(53, 0x24, 8);
TermWhiteInit(54, 0x25, 8);
TermWhiteInit(55, 0x58, 8);
TermWhiteInit(56, 0x59, 8);
TermWhiteInit(57, 0x5a, 8);
TermWhiteInit(58, 0x5b, 8);
TermWhiteInit(59, 0x4a, 8);
TermWhiteInit(60, 0x4b, 8);
TermWhiteInit(61, 0x32, 8);
TermWhiteInit(62, 0x33, 8);
TermWhiteInit(63, 0x34, 8);
//-------------------------------------------------------------------
MarkUpWhiteInit(64, 0x1b, 5);
MarkUpWhiteInit(128, 0x12, 5);
MarkUpWhiteInit(192, 0x17, 6);
MarkUpWhiteInit(256, 0x37, 7);
MarkUpWhiteInit(320, 0x36, 8);
MarkUpWhiteInit(384, 0x37, 8);
MarkUpWhiteInit(448, 0x64, 8);
MarkUpWhiteInit(512, 0x65, 8);
MarkUpWhiteInit(576, 0x68, 8);
MarkUpWhiteInit(640, 0x67, 8);
MarkUpWhiteInit(704, 0xcc, 9);
MarkUpWhiteInit(768, 0xcd, 9);
MarkUpWhiteInit(832, 0xd2, 9);
MarkUpWhiteInit(896, 0xd3, 9);
MarkUpWhiteInit(960, 0xd4, 9);
MarkUpWhiteInit(1024, 0xd5, 9);
MarkUpWhiteInit(1088, 0xd6, 9);
MarkUpWhiteInit(1152, 0xd7, 9);
MarkUpWhiteInit(1216, 0xd8, 9);
MarkUpWhiteInit(1280, 0xd9, 9);
MarkUpWhiteInit(1344, 0xda, 9);
MarkUpWhiteInit(1408, 0xdb, 9);
MarkUpWhiteInit(1472, 0x98, 9);
MarkUpWhiteInit(1536, 0x99, 9);
MarkUpWhiteInit(1600, 0x9a, 9);
MarkUpWhiteInit(1664, 0x18, 6);
MarkUpWhiteInit(1728, 0x9b, 9);
//-------------------------------------------------------------------
TermBlackInit(0, 0x37, 10);
TermBlackInit(1, 0x2, 3);
TermBlackInit(2, 0x3, 2);
TermBlackInit(3, 0x2, 2);
TermBlackInit(4, 0x3, 3);
TermBlackInit(5, 0x3, 4);
TermBlackInit(6, 0x2, 4);
TermBlackInit(7, 0x3, 5);
TermBlackInit(8, 0x5, 6);
TermBlackInit(9, 0x4, 6);
TermBlackInit(10, 0x4, 7);
TermBlackInit(11, 0x5, 7);
TermBlackInit(12, 0x7, 7);
TermBlackInit(13, 0x4, 8);
TermBlackInit(14, 0x7, 8);
TermBlackInit(15, 0x18, 9);
TermBlackInit(16, 0x17, 10);
TermBlackInit(17, 0x18, 10);
TermBlackInit(18, 0x8, 10);
TermBlackInit(19, 0x67, 11);
TermBlackInit(20, 0x68, 11);
TermBlackInit(21, 0x6c, 11);
TermBlackInit(22, 0x37, 11);
TermBlackInit(23, 0x28, 11);
TermBlackInit(24, 0x17, 11);
TermBlackInit(25, 0x18, 11);
TermBlackInit(26, 0xca, 12);
TermBlackInit(27, 0xcb, 12);
TermBlackInit(28, 0xcc, 12);
TermBlackInit(29, 0xcd, 12);
TermBlackInit(30, 0x68, 12);
TermBlackInit(31, 0x69, 12);
TermBlackInit(32, 0x6a, 12);
TermBlackInit(33, 0x6b, 12);
TermBlackInit(34, 0xd2, 12);
TermBlackInit(35, 0xd3, 12);
TermBlackInit(36, 0xd4, 12);
TermBlackInit(37, 0xd5, 12);
TermBlackInit(38, 0xd6, 12);
TermBlackInit(39, 0xd7, 12);
TermBlackInit(40, 0x6c, 12);
TermBlackInit(41, 0x6d, 12);
TermBlackInit(42, 0xda, 12);
TermBlackInit(43, 0xdb, 12);
TermBlackInit(44, 0x54, 12);
TermBlackInit(45, 0x55, 12);
TermBlackInit(46, 0x56, 12);
TermBlackInit(47, 0x57, 12);
TermBlackInit(48, 0x64, 12);
TermBlackInit(49, 0x65, 12);
TermBlackInit(50, 0x52, 12);
TermBlackInit(51, 0x53, 12);
TermBlackInit(52, 0x24, 12);
TermBlackInit(53, 0x37, 12);
TermBlackInit(54, 0x38, 12);
TermBlackInit(55, 0x27, 12);
TermBlackInit(56, 0x28, 12);
TermBlackInit(57, 0x58, 12);
TermBlackInit(58, 0x59, 12);
TermBlackInit(59, 0x2b, 12);
TermBlackInit(60, 0x2c, 12);
TermBlackInit(61, 0x5a, 12);
TermBlackInit(62, 0x66, 12);
TermBlackInit(63, 0x67, 12);
//-------------------------------------------------------------------
MarkUpBlackInit(64, 0xf, 10);
MarkUpBlackInit(128, 0xc8, 12);
MarkUpBlackInit(192, 0xc9, 12);
MarkUpBlackInit(256, 0x5b, 12);
MarkUpBlackInit(320, 0x33, 12);
MarkUpBlackInit(384, 0x34, 12);
MarkUpBlackInit(448, 0x35, 12);
MarkUpBlackInit(512, 0x6c, 13);
MarkUpBlackInit(576, 0x6d, 13);
MarkUpBlackInit(640, 0x4a, 13);
MarkUpBlackInit(704, 0x4b, 13);
MarkUpBlackInit(768, 0x4c, 13);
MarkUpBlackInit(832, 0x4d, 13);
MarkUpBlackInit(896, 0x72, 13);
MarkUpBlackInit(960, 0x73, 13);
MarkUpBlackInit(1024, 0x74, 13);
MarkUpBlackInit(1088, 0x75, 13);
MarkUpBlackInit(1152, 0x76, 13);
MarkUpBlackInit(1216, 0x77, 13);
MarkUpBlackInit(1280, 0x52, 13);
MarkUpBlackInit(1344, 0x53, 13);
MarkUpBlackInit(1408, 0x54, 13);
MarkUpBlackInit(1472, 0x55, 13);
MarkUpBlackInit(1536, 0x5a, 13);
MarkUpBlackInit(1600, 0x5b, 13);
MarkUpBlackInit(1664, 0x64, 13);
MarkUpBlackInit(1728, 0x65, 13);
//-------------------------------------------------------------------
MarkUpAddInit(1792, 0x8, 11);
MarkUpAddInit(1856, 0xc, 11);
MarkUpAddInit(1920, 0xd, 11);
MarkUpAddInit(1984, 0x12, 12);
MarkUpAddInit(2048, 0x13, 12);
MarkUpAddInit(2112, 0x14, 12);
MarkUpAddInit(2176, 0x15, 12);
MarkUpAddInit(2240, 0x16, 12);
MarkUpAddInit(2304, 0x17, 12);
MarkUpAddInit(2368, 0x1c, 12);
MarkUpAddInit(2432, 0x1d, 12);
MarkUpAddInit(2496, 0x1e, 12);
MarkUpAddInit(2560, 0x1f, 12);
//-------------------------------------------------------------------
COMP_CATCHTHIS
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
} // end namespace COMP
Reference in a new issue Copy permalink