summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Makefile.am19
-rw-r--r--aac-enc-dabplus-zmq.c169
-rw-r--r--configure.ac26
-rw-r--r--contrib/lib_crc.c459
-rw-r--r--contrib/lib_crc.h66
-rw-r--r--mot-encoder.c638
6 files changed, 1308 insertions, 69 deletions
diff --git a/Makefile.am b/Makefile.am
index 5040d3e..ff9e1b9 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -33,25 +33,26 @@ lib_LTLIBRARIES = libfdk-aac.la
libfdk_aac_la_LDFLAGS = -version-info @FDK_AAC_VERSION@ -no-undefined \
-export-symbols $(top_srcdir)/fdk-aac.sym
-if EXAMPLE
-
aac_enc_LDADD = libfdk-aac.la
aac_enc_SOURCES = aac-enc.c wavreader.c
aac_enc_dabplus_LDADD = libfdk-aac.la -lfec
aac_enc_dabplus_SOURCES = aac-enc-dabplus.c wavreader.c
-if HAVE_ZEROMQ_TEST
aac_enc_dabplus_zmq_LDADD = libfdk-aac.la -lfec -lzmq
-aac_enc_dabplus_zmq_SOURCES = aac-enc-dabplus-zmq.c wavreader.c
+aac_enc_dabplus_zmq_SOURCES = aac-enc-dabplus-zmq.c wavreader.c \
+ contrib/lib_crc.c
+
+mot_encoder_CFLAGS = @MAGICKWAND_CPPFLAGS@ -Icontrib
+mot_encoder_LDADD = @MAGICKWAND_LDADD@
+mot_encoder_SOURCES = mot-encoder.c contrib/lib_crc.c
-bin_PROGRAMS = aac-enc$(EXEEXT) aac-enc-dabplus$(EXEEXT) aac-enc-dabplus-zmq$(EXEEXT)
-else
-bin_PROGRAMS = aac-enc$(EXEEXT) aac-enc-dabplus$(EXEEXT)
-endif
+bin_PROGRAMS = aac-enc$(EXEEXT) \
+ aac-enc-dabplus$(EXEEXT) \
+ aac-enc-dabplus-zmq$(EXEEXT) \
+ mot-encoder$(EXEEXT)
noinst_HEADERS = wavreader.h
-endif
AACDEC_SRC = \
libAACdec/src/aacdec_drc.cpp \
diff --git a/aac-enc-dabplus-zmq.c b/aac-enc-dabplus-zmq.c
index 9122dc2..add317b 100644
--- a/aac-enc-dabplus-zmq.c
+++ b/aac-enc-dabplus-zmq.c
@@ -1,19 +1,20 @@
/* ------------------------------------------------------------------
* Copyright (C) 2011 Martin Storsjo
- * Copyright (C) 2013 Matthias P. Braendli
+ * Copyright (C) 2013,2014 Matthias P. Braendli
+ * Copyright (C) 2014 CSP Innovazione nelle ICT s.c.a r.l. (http://www.csp.it/)
*
- * 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
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
*
- * http://www.apache.org/licenses/LICENSE-2.0
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
*
- * 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.
+ * You should have received a copy of the GNU General Public License
+ * along with this program If not, see <http://www.gnu.org/licenses/>.
* -------------------------------------------------------------------
*/
@@ -29,8 +30,23 @@
#include "wavreader.h"
#include <fec.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+
+#include "contrib/lib_crc.h"
+
+#define MIN(a,b) (((a)<(b))?(a):(b))
+#define MAX(a,b) (((a)>(b))?(a):(b))
void usage(const char* name) {
+ fprintf(stderr, "fdk-aac-dabplus HE-AACv2 encoder for DAB+\n\n");
+ fprintf(stderr, "With ZeroMQ output for ODR-DabMux\n");
+ fprintf(stderr, "and PAD (DLS and MOT Slideshow) by http://www.csp.it\n");
+ fprintf(stderr, "\n");
+ fprintf(stderr, "http://opendigitalradio.org\n");
+ fprintf(stderr, "\nUsage:\n");
fprintf(stderr, "%s [OPTION...]\n", name);
fprintf(stderr,
" -b, --bitrate={ 8, 16, ..., 192 } Output bitrate in kbps. Must be 8 multiple.\n"
@@ -40,7 +56,7 @@ void usage(const char* name) {
" -o, --output=URI Output zmq uri. (e.g. 'tcp://*:9000')\n"
" -a, --afterburner Turn on AAC encoder quality increaser.\n"
//" -m, --message Turn on AAC frame messages.\n"
-//" -p, --pad=BYTES Set PAD size in bytes.\n"
+" -p, --pad=BYTES Set PAD size in bytes.\n"
" -f, --format={ wav, raw } Set input file format (default: wav).\n"
" -c, --channels={ 1, 2 } Nb of input channels for raw input (default: 2).\n"
" -r, --rate={ 32000, 48000 } Sample rate for raw input (default: 48000).\n"
@@ -79,25 +95,35 @@ int main(int argc, char *argv[]) {
CHANNEL_MODE mode;
AACENC_InfoStruct info = { 0 };
+ int pad_fd;
+ unsigned char pad_buf[128];
+ int padlen;
+
void *zmq_context = zmq_ctx_new();
void *zmq_sock = NULL;
const struct option longopts[] = {
{"bitrate", required_argument, 0, 'b'},
- {"input", required_argument, 0, 'i'},
- {"output", required_argument, 0, 'o'},
- {"format", required_argument, 0, 'f'},
- {"rate", required_argument, 0, 'r'},
- {"channels", required_argument, 0, 'c'},
- //{"lp", no_argument, 0, 'l'},
- {"afterburner", no_argument, 0, 'a'},
- {"help", no_argument, 0, 'h'},
- {0,0,0,0},
+ {"input", required_argument, 0, 'i'},
+ {"output", required_argument, 0, 'o'},
+ {"format", required_argument, 0, 'f'},
+ {"rate", required_argument, 0, 'r'},
+ {"channels", required_argument, 0, 'c'},
+ {"pad", required_argument, 0, 'p'},
+ //{"lp", no_argument, 0, 'l'},
+ {"afterburner", no_argument, 0, 'a'},
+ {"help", no_argument, 0, 'h'},
+ {0,0,0,0},
};
+ if (argc == 1) {
+ usage(argv[0]);
+ return 0;
+ }
+
int index;
while(ch != -1) {
- ch = getopt_long(argc, argv, "tlhab:c:i:o:r:f:", longopts, &index);
+ ch = getopt_long(argc, argv, "tlhab:c:i:o:r:f:p:", longopts, &index);
switch (ch) {
case 'f':
if(strcmp(optarg, "raw")==0) {
@@ -123,6 +149,9 @@ int main(int argc, char *argv[]) {
case 'o':
outuri = optarg;
break;
+ case 'p':
+ padlen = atoi(optarg);
+ break;
case '?':
case 'h':
usage(argv[0]);
@@ -131,9 +160,29 @@ int main(int argc, char *argv[]) {
}
if(subchannel_index < 1 || subchannel_index > 24) {
- fprintf(stderr, "Bad subchannels number: %d, try other bitrate.\n", subchannel_index);
+ fprintf(stderr, "Bad subchannels number: %d, try other bitrate.\n",
+ subchannel_index);
return 1;
}
+ if(padlen != 0) {
+ int flags;
+ if (mkfifo("/tmp/pad.fifo", S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH) != 0) {
+ if (errno != EEXIST) {
+ fprintf(stderr, "Can't create pad file: %d!\n", errno);
+ return 1;
+ }
+ }
+ pad_fd = open("/tmp/pad.fifo", O_RDONLY | O_NONBLOCK);
+ if (pad_fd == -1) {
+ fprintf(stderr, "Can't open pad file!\n");
+ return 1;
+ }
+ flags = fcntl(pad_fd, F_GETFL, 0);
+ if (fcntl(pad_fd, F_SETFL, flags | O_NONBLOCK)) {
+ fprintf(stderr, "Can't set non-blocking mode in pad file!\n");
+ return 1;
+ }
+ }
if(raw_input) {
if(infile && strcmp(infile, "-")) {
@@ -217,7 +266,7 @@ int main(int argc, char *argv[]) {
return 1;
}
if (aacEncoder_SetParam(handle, AACENC_SAMPLERATE, sample_rate) != AACENC_OK) {
- fprintf(stderr, "Unable to set the AOT\n");
+ fprintf(stderr, "Unable to set the samplerate\n");
return 1;
}
if (aacEncoder_SetParam(handle, AACENC_CHANNELMODE, mode) != AACENC_OK) {
@@ -229,7 +278,7 @@ int main(int argc, char *argv[]) {
return 1;
}
if (aacEncoder_SetParam(handle, AACENC_GRANULE_LENGTH, 960) != AACENC_OK) {
- fprintf(stderr, "Unable to set the AOT\n");
+ fprintf(stderr, "Unable to set the granule length\n");
return 1;
}
if (aacEncoder_SetParam(handle, AACENC_TRANSMUX, TT_DABPLUS) != AACENC_OK) {
@@ -252,6 +301,10 @@ int main(int argc, char *argv[]) {
fprintf(stderr, "Unable to set the afterburner mode\n");
return 1;
}
+ if (aacEncoder_SetParam(handle, AACENC_ANCILLARY_BITRATE, 0) != AACENC_OK) {
+ fprintf(stderr, "Unable to set the ancillary bitrate\n");
+ return 1;
+ }
if (aacEncEncode(handle, NULL, NULL, NULL, NULL) != AACENC_OK) {
fprintf(stderr, "Unable to initialize the encoder\n");
return 1;
@@ -294,44 +347,74 @@ int main(int argc, char *argv[]) {
AACENC_BufDesc in_buf = { 0 }, out_buf = { 0 };
AACENC_InArgs in_args = { 0 };
AACENC_OutArgs out_args = { 0 };
- int in_identifier = IN_AUDIO_DATA;
- int in_size, in_elem_size;
+ int in_identifier[] = {IN_AUDIO_DATA, IN_ANCILLRY_DATA};
+ int in_size[2], in_elem_size[2];
int out_identifier = OUT_BITSTREAM_DATA;
int out_size, out_elem_size;
- int read=0, i;
+ int pcmread=0, i, ret;
int send_error;
- void *in_ptr, *out_ptr;
+ void *in_ptr[2], *out_ptr;
AACENC_ERROR err;
+ // Read data from the PAD fifo
+ if (padlen != 0) {
+ ret = read(pad_fd, pad_buf, padlen);
+ }
+ else {
+ ret = 0;
+ }
+
+ if(ret < 0 && errno == EAGAIN) {
+ // If this condition passes, there is no data to be read
+ in_buf.numBufs = 1; // Samples;
+ }
+ else if(ret >= 0) {
+ // Otherwise, you're good to go and buffer should contain "count" bytes.
+ in_buf.numBufs = 2; // Samples + Data;
+ }
+ else {
+ // Some other error occurred during read.
+ fprintf(stderr, "Unable to read from PAD!\n");
+ break;
+ }
+
if(raw_input) {
if(fread(input_buf, input_size, 1, in_fh) == 1) {
- read = input_size;
+ pcmread = input_size;
} else {
fprintf(stderr, "Unable to read from input!\n");
break;
}
} else {
- read = wav_read_data(wav, input_buf, input_size);
+ pcmread = wav_read_data(wav, input_buf, input_size);
}
- for (i = 0; i < read/2; i++) {
+ for (i = 0; i < pcmread/2; i++) {
const uint8_t* in = &input_buf[2*i];
convert_buf[i] = in[0] | (in[1] << 8);
}
- if (read <= 0) {
+ if (pcmread <= 0) {
in_args.numInSamples = -1;
} else {
- in_ptr = convert_buf;
- in_size = read;
- in_elem_size = 2;
-
- in_args.numInSamples = read/2;
- in_buf.numBufs = 1;
- in_buf.bufs = &in_ptr;
- in_buf.bufferIdentifiers = &in_identifier;
- in_buf.bufSizes = &in_size;
- in_buf.bufElSizes = &in_elem_size;
+ in_ptr[0] = convert_buf;
+ in_ptr[1] = pad_buf;
+ in_size[0] = pcmread;
+ in_size[1] = padlen;
+
+ in_elem_size[0] = 2;
+ in_elem_size[1] = sizeof(UCHAR);
+
+ in_args.numInSamples = pcmread/2;
+ in_args.numAncBytes = padlen;
+
+ //in_buf.numBufs = 2; // Samples + Data
+
+ in_buf.bufs = (void**)&in_ptr;
+ in_buf.bufferIdentifiers = in_identifier;
+ in_buf.bufSizes = in_size;
+ in_buf.bufElSizes = in_elem_size;
+
}
out_ptr = outbuf;
out_size = sizeof(outbuf);
diff --git a/configure.ac b/configure.ac
index 98f4066..5283420 100644
--- a/configure.ac
+++ b/configure.ac
@@ -7,15 +7,6 @@ AC_CONFIG_MACRO_DIR([m4])
AM_INIT_AUTOMAKE([tar-ustar foreign])
m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
-dnl Various options for configure
-AC_ARG_ENABLE([example],
- [AS_HELP_STRING([--enable-example],
- [enable example encoding program (default is no)])],
- [example=$enableval], [example=no])
-
-dnl Automake conditionals to set
-AM_CONDITIONAL(EXAMPLE, test x$example = xyes)
-
dnl Checks for programs.
AC_PROG_CC
AC_PROG_CXX
@@ -24,15 +15,16 @@ LT_INIT
AC_CHECK_LIB([m], [sin])
-# fdk-aac-dabplus-zmq needs ZeroMQ
-AC_ARG_ENABLE([zmq],
- [AS_HELP_STRING([--enable-zmq], [Enable fdk-aac-dabplus-zmq with ZeroMQ output])]
- )
-
-AS_IF(test "x$enable_zmq" = "xyes",
- AC_CHECK_LIB(zmq, zmq_init, , AC_MSG_ERROR(ZeroMQ libzmq is required)))
+AC_CHECK_LIB(zmq, zmq_init, , AC_MSG_ERROR(ZeroMQ libzmq is required))
-AM_CONDITIONAL(HAVE_ZEROMQ_TEST, test "x$enable_zmq" = "xyes")
+if pkg-config MagickWand; then
+ MAGICKWAND_CFLAGS=`pkg-config MagickWand --cflags`
+ MAGICKWAND_LDADD=`pkg-config MagickWand --libs`
+ AC_SUBST(MAGICKWAND_CPPFLAGS)
+ AC_SUBST(MAGICKWAND_LDADD)
+else
+ AC_MSG_ERROR(MagickWand not found)
+fi
dnl soname version to use
dnl goes by ‘current[:revision[:age]]’ with the soname ending up as
diff --git a/contrib/lib_crc.c b/contrib/lib_crc.c
new file mode 100644
index 0000000..8f71ffb
--- /dev/null
+++ b/contrib/lib_crc.c
@@ -0,0 +1,459 @@
+#include "lib_crc.h"
+
+
+
+ /*******************************************************************\
+ * *
+ * Library : lib_crc *
+ * File : lib_crc.c *
+ * Author : Lammert Bies 1999-2008 *
+ * E-mail : info@lammertbies.nl *
+ * Language : ANSI C *
+ * *
+ * *
+ * Description *
+ * =========== *
+ * *
+ * The file lib_crc.c contains the private and public func- *
+ * tions used for the calculation of CRC-16, CRC-CCITT and *
+ * CRC-32 cyclic redundancy values. *
+ * *
+ * *
+ * Dependencies *
+ * ============ *
+ * *
+ * lib_crc.h CRC definitions and prototypes *
+ * *
+ * *
+ * Modification history *
+ * ==================== *
+ * *
+ * Date Version Comment *
+ * *
+ * 2008-04-20 1.16 Added CRC-CCITT calculation for Kermit *
+ * *
+ * 2007-04-01 1.15 Added CRC16 calculation for Modbus *
+ * *
+ * 2007-03-28 1.14 Added CRC16 routine for Sick devices *
+ * *
+ * 2005-12-17 1.13 Added CRC-CCITT with initial 0x1D0F *
+ * *
+ * 2005-05-14 1.12 Added CRC-CCITT with start value 0 *
+ * *
+ * 2005-02-05 1.11 Fixed bug in CRC-DNP routine *
+ * *
+ * 2005-02-04 1.10 Added CRC-DNP routines *
+ * *
+ * 1999-02-21 1.01 Added FALSE and TRUE mnemonics *
+ * *
+ * 1999-01-22 1.00 Initial source *
+ * *
+ \*******************************************************************/
+
+
+
+ /*******************************************************************\
+ * *
+ * #define P_xxxx *
+ * *
+ * The CRC's are computed using polynomials. The coefficients *
+ * for the algorithms are defined by the following constants. *
+ * *
+ \*******************************************************************/
+
+#define P_16 0xA001
+#define P_32 0xEDB88320L
+#define P_CCITT 0x1021
+#define P_DNP 0xA6BC
+#define P_KERMIT 0x8408
+#define P_SICK 0x8005
+
+
+
+ /*******************************************************************\
+ * *
+ * static int crc_tab...init *
+ * static unsigned ... crc_tab...[] *
+ * *
+ * The algorithms use tables with precalculated values. This *
+ * speeds up the calculation dramaticaly. The first time the *
+ * CRC function is called, the table for that specific calcu- *
+ * lation is set up. The ...init variables are used to deter- *
+ * mine if the initialization has taken place. The calculated *
+ * values are stored in the crc_tab... arrays. *
+ * *
+ * The variables are declared static. This makes them invisi- *
+ * ble for other modules of the program. *
+ * *
+ \*******************************************************************/
+
+static int crc_tab16_init = FALSE;
+static int crc_tab32_init = FALSE;
+static int crc_tabccitt_init = FALSE;
+static int crc_tabdnp_init = FALSE;
+static int crc_tabkermit_init = FALSE;
+
+static unsigned short crc_tab16[256];
+static unsigned long crc_tab32[256];
+static unsigned short crc_tabccitt[256];
+static unsigned short crc_tabdnp[256];
+static unsigned short crc_tabkermit[256];
+
+
+
+ /*******************************************************************\
+ * *
+ * static void init_crc...tab(); *
+ * *
+ * Three local functions are used to initialize the tables *
+ * with values for the algorithm. *
+ * *
+ \*******************************************************************/
+
+static void init_crc16_tab( void );
+static void init_crc32_tab( void );
+static void init_crcccitt_tab( void );
+static void init_crcdnp_tab( void );
+static void init_crckermit_tab( void );
+
+
+
+ /*******************************************************************\
+ * *
+ * unsigned short update_crc_ccitt( unsigned long crc, char c ); *
+ * *
+ * The function update_crc_ccitt calculates a new CRC-CCITT *
+ * value based on the previous value of the CRC and the next *
+ * byte of the data to be checked. *
+ * *
+ \*******************************************************************/
+
+unsigned short update_crc_ccitt( unsigned short crc, char c ) {
+
+ unsigned short tmp, short_c;
+
+ short_c = 0x00ff & (unsigned short) c;
+
+ if ( ! crc_tabccitt_init ) init_crcccitt_tab();
+
+ tmp = (crc >> 8) ^ short_c;
+ crc = (crc << 8) ^ crc_tabccitt[tmp];
+
+ return crc;
+
+} /* update_crc_ccitt */
+
+
+
+ /*******************************************************************\
+ * *
+ * unsigned short update_crc_sick( *
+ * unsigned long crc, char c, char prev_byte ); *
+ * *
+ * The function update_crc_sick calculates a new CRC-SICK *
+ * value based on the previous value of the CRC and the next *
+ * byte of the data to be checked. *
+ * *
+ \*******************************************************************/
+
+unsigned short update_crc_sick( unsigned short crc, char c, char prev_byte ) {
+
+ unsigned short short_c, short_p;
+
+ short_c = 0x00ff & (unsigned short) c;
+ short_p = ( 0x00ff & (unsigned short) prev_byte ) << 8;
+
+ if ( crc & 0x8000 ) crc = ( crc << 1 ) ^ P_SICK;
+ else crc = crc << 1;
+
+ crc &= 0xffff;
+ crc ^= ( short_c | short_p );
+
+ return crc;
+
+} /* update_crc_sick */
+
+
+
+ /*******************************************************************\
+ * *
+ * unsigned short update_crc_16( unsigned short crc, char c ); *
+ * *
+ * The function update_crc_16 calculates a new CRC-16 value *
+ * based on the previous value of the CRC and the next byte *
+ * of the data to be checked. *
+ * *
+ \*******************************************************************/
+
+unsigned short update_crc_16( unsigned short crc, char c ) {
+
+ unsigned short tmp, short_c;
+
+ short_c = 0x00ff & (unsigned short) c;
+
+ if ( ! crc_tab16_init ) init_crc16_tab();
+
+ tmp = crc ^ short_c;
+ crc = (crc >> 8) ^ crc_tab16[ tmp & 0xff ];
+
+ return crc;
+
+} /* update_crc_16 */
+
+
+
+ /*******************************************************************\
+ * *
+ * unsigned short update_crc_kermit( unsigned short crc, char c ); *
+ * *
+ * The function update_crc_kermit calculates a new CRC value *
+ * based on the previous value of the CRC and the next byte *
+ * of the data to be checked. *
+ * *
+ \*******************************************************************/
+
+unsigned short update_crc_kermit( unsigned short crc, char c ) {
+
+ unsigned short tmp, short_c;
+
+ short_c = 0x00ff & (unsigned short) c;
+
+ if ( ! crc_tabkermit_init ) init_crckermit_tab();
+
+ tmp = crc ^ short_c;
+ crc = (crc >> 8) ^ crc_tabkermit[ tmp & 0xff ];
+
+ return crc;
+
+} /* update_crc_kermit */
+
+
+
+ /*******************************************************************\
+ * *
+ * unsigned short update_crc_dnp( unsigned short crc, char c ); *
+ * *
+ * The function update_crc_dnp calculates a new CRC-DNP value *
+ * based on the previous value of the CRC and the next byte *
+ * of the data to be checked. *
+ * *
+ \*******************************************************************/
+
+unsigned short update_crc_dnp( unsigned short crc, char c ) {
+
+ unsigned short tmp, short_c;
+
+ short_c = 0x00ff & (unsigned short) c;
+
+ if ( ! crc_tabdnp_init ) init_crcdnp_tab();
+
+ tmp = crc ^ short_c;
+ crc = (crc >> 8) ^ crc_tabdnp[ tmp & 0xff ];
+
+ return crc;
+
+} /* update_crc_dnp */
+
+
+
+ /*******************************************************************\
+ * *
+ * unsigned long update_crc_32( unsigned long crc, char c ); *
+ * *
+ * The function update_crc_32 calculates a new CRC-32 value *
+ * based on the previous value of the CRC and the next byte *
+ * of the data to be checked. *
+ * *
+ \*******************************************************************/
+
+unsigned long update_crc_32( unsigned long crc, char c ) {
+
+ unsigned long tmp, long_c;
+
+ long_c = 0x000000ffL & (unsigned long) c;
+
+ if ( ! crc_tab32_init ) init_crc32_tab();
+
+ tmp = crc ^ long_c;
+ crc = (crc >> 8) ^ crc_tab32[ tmp & 0xff ];
+
+ return crc;
+
+} /* update_crc_32 */
+
+
+
+ /*******************************************************************\
+ * *
+ * static void init_crc16_tab( void ); *
+ * *
+ * The function init_crc16_tab() is used to fill the array *
+ * for calculation of the CRC-16 with values. *
+ * *
+ \*******************************************************************/
+
+static void init_crc16_tab( void ) {
+
+ int i, j;
+ unsigned short crc, c;
+
+ for (i=0; i<256; i++) {
+
+ crc = 0;
+ c = (unsigned short) i;
+
+ for (j=0; j<8; j++) {
+
+ if ( (crc ^ c) & 0x0001 ) crc = ( crc >> 1 ) ^ P_16;
+ else crc = crc >> 1;
+
+ c = c >> 1;
+ }
+
+ crc_tab16[i] = crc;
+ }
+
+ crc_tab16_init = TRUE;
+
+} /* init_crc16_tab */
+
+
+
+ /*******************************************************************\
+ * *
+ * static void init_crckermit_tab( void ); *
+ * *
+ * The function init_crckermit_tab() is used to fill the array *
+ * for calculation of the CRC Kermit with values. *
+ * *
+ \*******************************************************************/
+
+static void init_crckermit_tab( void ) {
+
+ int i, j;
+ unsigned short crc, c;
+
+ for (i=0; i<256; i++) {
+
+ crc = 0;
+ c = (unsigned short) i;
+
+ for (j=0; j<8; j++) {
+
+ if ( (crc ^ c) & 0x0001 ) crc = ( crc >> 1 ) ^ P_KERMIT;
+ else crc = crc >> 1;
+
+ c = c >> 1;
+ }
+
+ crc_tabkermit[i] = crc;
+ }
+
+ crc_tabkermit_init = TRUE;
+
+} /* init_crckermit_tab */
+
+
+
+ /*******************************************************************\
+ * *
+ * static void init_crcdnp_tab( void ); *
+ * *
+ * The function init_crcdnp_tab() is used to fill the array *
+ * for calculation of the CRC-DNP with values. *
+ * *
+ \*******************************************************************/
+
+static void init_crcdnp_tab( void ) {
+
+ int i, j;
+ unsigned short crc, c;
+
+ for (i=0; i<256; i++) {
+
+ crc = 0;
+ c = (unsigned short) i;
+
+ for (j=0; j<8; j++) {
+
+ if ( (crc ^ c) & 0x0001 ) crc = ( crc >> 1 ) ^ P_DNP;
+ else crc = crc >> 1;
+
+ c = c >> 1;
+ }
+
+ crc_tabdnp[i] = crc;
+ }
+
+ crc_tabdnp_init = TRUE;
+
+} /* init_crcdnp_tab */
+
+
+
+ /*******************************************************************\
+ * *
+ * static void init_crc32_tab( void ); *
+ * *
+ * The function init_crc32_tab() is used to fill the array *
+ * for calculation of the CRC-32 with values. *
+ * *
+ \*******************************************************************/
+
+static void init_crc32_tab( void ) {
+
+ int i, j;
+ unsigned long crc;
+
+ for (i=0; i<256; i++) {
+
+ crc = (unsigned long) i;
+
+ for (j=0; j<8; j++) {
+
+ if ( crc & 0x00000001L ) crc = ( crc >> 1 ) ^ P_32;
+ else crc = crc >> 1;
+ }
+
+ crc_tab32[i] = crc;
+ }
+
+ crc_tab32_init = TRUE;
+
+} /* init_crc32_tab */
+
+
+
+ /*******************************************************************\
+ * *
+ * static void init_crcccitt_tab( void ); *
+ * *
+ * The function init_crcccitt_tab() is used to fill the array *
+ * for calculation of the CRC-CCITT with values. *
+ * *
+ \*******************************************************************/
+
+static void init_crcccitt_tab( void ) {
+
+ int i, j;
+ unsigned short crc, c;
+
+ for (i=0; i<256; i++) {
+
+ crc = 0;
+ c = ((unsigned short) i) << 8;
+
+ for (j=0; j<8; j++) {
+
+ if ( (crc ^ c) & 0x8000 ) crc = ( crc << 1 ) ^ P_CCITT;
+ else crc = crc << 1;
+
+ c = c << 1;
+ }
+
+ crc_tabccitt[i] = crc;
+ }
+
+ crc_tabccitt_init = TRUE;
+
+} /* init_crcccitt_tab */
diff --git a/contrib/lib_crc.h b/contrib/lib_crc.h
new file mode 100644
index 0000000..0e559e6
--- /dev/null
+++ b/contrib/lib_crc.h
@@ -0,0 +1,66 @@
+ /*******************************************************************\
+ * *
+ * Library : lib_crc *
+ * File : lib_crc.h *
+ * Author : Lammert Bies 1999-2008 *
+ * E-mail : info@lammertbies.nl *
+ * Language : ANSI C *
+ * *
+ * *
+ * Description *
+ * =========== *
+ * *
+ * The file lib_crc.h contains public definitions and proto- *
+ * types for the CRC functions present in lib_crc.c. *
+ * *
+ * *
+ * Dependencies *
+ * ============ *
+ * *
+ * none *
+ * *
+ * *
+ * Modification history *
+ * ==================== *
+ * *
+ * Date Version Comment *
+ * *
+ * 2008-04-20 1.16 Added CRC-CCITT routine for Kermit *
+ * *
+ * 2007-04-01 1.15 Added CRC16 calculation for Modbus *
+ * *
+ * 2007-03-28 1.14 Added CRC16 routine for Sick devices *
+ * *
+ * 2005-12-17 1.13 Added CRC-CCITT with initial 0x1D0F *
+ * *
+ * 2005-02-14 1.12 Added CRC-CCITT with initial 0x0000 *
+ * *
+ * 2005-02-05 1.11 Fixed bug in CRC-DNP routine *
+ * *
+ * 2005-02-04 1.10 Added CRC-DNP routines *
+ * *
+ * 2005-01-07 1.02 Changes in tst_crc.c *
+ * *
+ * 1999-02-21 1.01 Added FALSE and TRUE mnemonics *
+ * *
+ * 1999-01-22 1.00 Initial source *
+ * *
+ \*******************************************************************/
+
+
+
+#define CRC_VERSION "1.16"
+
+
+
+#define FALSE 0
+#define TRUE 1
+
+
+
+unsigned short update_crc_16( unsigned short crc, char c );
+unsigned long update_crc_32( unsigned long crc, char c );
+unsigned short update_crc_ccitt( unsigned short crc, char c );
+unsigned short update_crc_dnp( unsigned short crc, char c );
+unsigned short update_crc_kermit( unsigned short crc, char c );
+unsigned short update_crc_sick( unsigned short crc, char c, char prev_byte );
diff --git a/mot-encoder.c b/mot-encoder.c
new file mode 100644
index 0000000..7325cee
--- /dev/null
+++ b/mot-encoder.c
@@ -0,0 +1,638 @@
+/*
+ Copyright (C) 2014 CSP Innovazione nelle ICT s.c.a r.l. (http://www.csp.it/)
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+ MotEncoder.c
+ Generete PAD data for MOT Slideshow and DLS
+
+ Authors:
+ Sergio Sagliocco <sergio.sagliocco@csp.it>
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <dirent.h>
+#include <wand/magick_wand.h>
+
+#include "lib_crc.h"
+
+#define MIN(a,b) (((a)<(b))?(a):(b))
+#define MAX(a,b) (((a)>(b))?(a):(b))
+
+#define MAXSEGLEN 8179
+#define MAXDLS 129
+
+typedef unsigned char UCHAR;
+typedef unsigned short int USHORT;
+
+typedef struct {
+ // MSC Data Group Header (extension field not supported)
+ unsigned char extflag; // 1 bit
+ unsigned char crcflag; // 1 bit
+ unsigned char segflag; // 1 bit
+ unsigned char accflag; // 1 bit
+ unsigned char dgtype; // 4 bits
+ unsigned char cindex; // 4 bits
+ unsigned char rindex; // 4 bits
+ /// Session header - Segment field
+ unsigned char last; // 1 bit
+ unsigned short int segnum; // 16 bits
+ // Session header - User access field
+ unsigned char rfa; // 3 bits
+ unsigned char tidflag; // 1 bit
+ unsigned char lenid; // 4 bits - Fixed to value 2 in this implemntation
+ unsigned short int tid; // 16 bits
+ // MSC data group data field
+ // Mot Segmentation header
+ unsigned char rcount; // 3 bits
+ unsigned short int seglen; // 13 bits
+ // Mot segment
+ unsigned char* segdata;
+ // MSC data group CRC
+ unsigned short int crc; // 16 bits
+} MSCDG;
+/*
+ typedef struct {
+// MOT HEADER CUSTOMIZED FOR SLIDESHOW APP
+unsigned int bodysize; // 28 bits
+unsigned short int headsize; // 13 bits
+unsigned char ctype; // 6 bits
+unsigned char sctype; // 9 bits
+unsigned char triggertime[5]; // 0x85 0x00 0x00 0x00 0x00 => NOW
+unsigned char contname[14]; // 0xCC 0x0C 0x00 imgXXXX.jpg
+} MOTSLIDEHDR;
+*/
+int encodeFile (char* fname, int fidx, int padlen);
+void createMotHeader(size_t blobsize, int fidx, char* mothdr, int* mothdrlen);
+void createMscDG(MSCDG* msc, unsigned short int dgtype, unsigned short int cindex, unsigned short int lastseg, unsigned short int tid, unsigned char* data, unsigned short int datalen);
+void packMscDG(unsigned char* mscblob, MSCDG* msc, unsigned short int *bsize);
+void writeMotPAD(unsigned char* mscdg, unsigned short int mscdgsize, unsigned short int padlen);
+void create_dls_datagroup (char* text, int padlen, unsigned char*** p_dlsdg, int* p_numdg);
+void writeDLS(int padlen);
+
+void usage(char* name)
+{
+ fprintf(stderr, "DAB MOT encoder\n"
+ "for slideshow and DLS\n\n"
+ "By CSP Innovazione nelle ICT s.c.a r.l. (http://www.csp.it/)\n\n"
+ "Reads image data from the specified directory, and outputs PAD data\n"
+ "on standard output\n"
+ "Reads DLS from /tmp/dls.file\n");
+ fprintf(stderr, "Usage: %s <dirname>\n", name);
+}
+
+int main (int argc, char *argv[])
+{
+ int len,fidx,ret;
+ struct dirent *pDirent;
+ DIR *pDir;
+ char imagepath[128];
+ char dlstext[MAXDLS],dlstextprev[MAXDLS];
+ int padlen=53;
+
+
+ if (argc < 2) {
+ usage(argv[0]);
+ return 0;
+ }
+
+ MagickWandGenesis();
+
+ fidx=0;
+ while(1) {
+ pDir = opendir (argv[1]);
+ if (pDir == NULL) {
+ printf ("Cannot open directory '%s'\n", argv[1]);
+ return 1;
+ }
+ if (fidx == 9999) fidx=0;
+ while ((pDirent = readdir(pDir)) != NULL) {
+ if (pDirent->d_name[0]!='.') {
+ sprintf (imagepath,"%s/%s",argv[1],pDirent->d_name);
+ ret=encodeFile(imagepath, fidx, padlen);
+ if (ret!=1) {
+ fprintf(stderr,"Error - Cannot encode file %s\n",pDirent->d_name);
+ } else {
+ fidx++;
+ writeDLS(padlen);
+ sleep(10);
+ }
+ }
+ }
+ closedir (pDir);
+ }
+ return 1;
+}
+
+int encodeFile (char* fname, int fidx, int padlen)
+{
+ int fd=0,ret,mothdrlen,nseg,lastseglen,i,last,curseglen;
+ unsigned char mothdr[32];
+ MagickWand *m_wand = NULL;
+ PixelWand *p_wand = NULL;
+ size_t blobsize,height,width;
+ unsigned char *blob = NULL, *curseg = NULL;
+ MagickBooleanType err;
+ MSCDG msc;
+ unsigned char mscblob[8200];
+ unsigned short int mscblobsize;
+ //float aspectRatio;
+
+
+ m_wand = NewMagickWand();
+ p_wand = NewPixelWand();
+ PixelSetColor(p_wand,"black");
+
+ err = MagickReadImage(m_wand,fname);
+ if (err==MagickFalse) {
+ fprintf(stderr,"Error - Unable to load image %s\n",fname);
+ ret=0;
+ goto RETURN;
+ }
+
+ height=MagickGetImageHeight(m_wand);
+ width=MagickGetImageWidth(m_wand);
+ //aspectRatio = (width * 1.0)/height;
+
+ fprintf(stderr,"Image: %s (id=%d). Original size: %d x %d. ",fname,fidx,width,height);
+
+ while (height>240 || width>320) {
+ if (height/240.0 > width/320.0) {
+ //width = height * aspectRatio;
+ width = width * 240.0 / height;
+ height = 240;
+ }
+ else {
+ //height = width * (1.0/aspectRatio);
+ height = height * 320.0 / width;
+ width = 320;
+ }
+ MagickResizeImage(m_wand,width,height,LanczosFilter,1);
+ }
+
+
+
+ height=MagickGetImageHeight(m_wand);
+ width=MagickGetImageWidth(m_wand);
+
+ MagickBorderImage(m_wand,p_wand,(320-width)/2,(240-height)/2);
+
+ MagickSetImageCompressionQuality(m_wand,75);
+ MagickSetImageFormat(m_wand,"jpg");
+ blob=MagickGetImagesBlob(m_wand, &blobsize);
+ fprintf(stderr,"Resized to %d x %d. Size after compression %d bytes\n",width,height,blobsize);
+
+ nseg=blobsize / MAXSEGLEN;
+ lastseglen=blobsize % MAXSEGLEN;
+ if (lastseglen !=0) nseg++;
+
+ createMotHeader(blobsize,fidx,mothdr,&mothdrlen);
+ // Create the MSC Data Group C-Structure
+ createMscDG(&msc,3,0,1,fidx,mothdr,mothdrlen);
+ // Generate the MSC DG frame (Figure 9 en 300 401)
+ packMscDG(mscblob,&msc,&mscblobsize);
+ writeMotPAD(mscblob,mscblobsize,padlen);
+
+ for (i=0;i<nseg;i++) {
+ curseg=blob+i*MAXSEGLEN;
+ if (i==nseg-1) {
+ curseglen=lastseglen;
+ last=1;
+ }
+ else {
+ curseglen=MAXSEGLEN;
+ last=0;
+ }
+
+ createMscDG(&msc,4,i,last,fidx,curseg,curseglen);
+ packMscDG(mscblob,&msc,&mscblobsize);
+ writeMotPAD(mscblob,mscblobsize,padlen);
+ }
+
+ ret=1;
+
+RETURN:
+ if (m_wand) {
+ m_wand = DestroyMagickWand(m_wand);
+ }
+ if (blob) {
+ free(blob);
+ }
+ return ret;
+}
+
+
+void createMotHeader(size_t blobsize, int fidx, char* mothdr,int* mothdrlen)
+{
+ int ret;
+ struct stat s;
+ char MotHeaderCore[7]= {0x00,0x00,0x00,0x00,0x0D,0x04,0x01};
+ char MotHeaderExt[19]= {0x85,0x00,0x00,0x00,0x00,0xcc,0x0c,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
+ char cntemp[12];
+ int i;
+
+ MotHeaderCore[0]=(blobsize<<4 & 0xFF000000)>>24;
+ MotHeaderCore[1]=(blobsize<<4 & 0x00FF0000)>>16;
+ MotHeaderCore[2]=(blobsize<<4 & 0x0000FF00)>>8;
+ MotHeaderCore[3]=(blobsize<<4 & 0x000000FF);
+
+ sprintf(cntemp,"img%04d.jpg",fidx);
+ for (i=0; i<sizeof(cntemp); i++) {
+ MotHeaderExt[8+i]=cntemp[i];
+ }
+ *mothdrlen=26;
+ for (i=0;i<7;i++)
+ mothdr[i]=MotHeaderCore[i];
+ for (i=0;i<19;i++)
+ mothdr[7+i]=MotHeaderExt[i];
+
+ return;
+}
+
+void createMscDG(MSCDG* msc, unsigned short int dgtype, unsigned short int cindex, unsigned short int lastseg, unsigned short int tid, unsigned char* data, unsigned short int datalen)
+{
+ msc->extflag=0;
+ msc->crcflag=1;
+ msc->segflag=1;
+ msc->accflag=1;
+ msc->dgtype=dgtype;
+ msc->cindex=cindex;
+ msc->rindex=0;
+ msc->last=lastseg;
+ msc->segnum=cindex;
+ msc->rfa=0;
+ msc->tidflag=1;
+ msc->lenid=2;
+ msc->tid=tid;
+ msc->segdata=data;
+ msc->rcount=0;
+ msc->seglen=datalen;
+
+ return;
+}
+
+
+void packMscDG(unsigned char* b, MSCDG* msc, unsigned short int* bsize) {
+
+ int i;
+ unsigned short int crc=0xFFFF;
+
+ b[0]=(msc->extflag<<7)|(msc->crcflag<<6)|(msc->segflag<<5)|(msc->accflag<<4)|msc->dgtype;
+ b[1]=(msc->cindex<<4)|msc->rindex;
+ b[2]=(msc->last<<7)|((msc->segnum & 0x7F00)>>8);
+ b[3]=msc->segnum & 0x00FF;
+ b[4]=0;
+ b[4]=(msc->rfa<<5)|(msc->tidflag<<4)|msc->lenid;
+ b[5]=(msc->tid & 0xFF00)>>8;
+ b[6]=msc->tid & 0x00FF;
+ b[7]=(msc->rcount<<5)|((msc->seglen & 0x1F00)>>8);
+ b[8]=msc->seglen & 0x00FF;
+
+ for (i=0;i<9;i++)
+ crc = update_crc_ccitt(crc, b[i]);
+
+ for(i=0;i<msc->seglen;i++) {
+ b[i+9]=(msc->segdata)[i];
+ crc = update_crc_ccitt(crc, b[i+9]);
+ }
+
+ crc=~crc;
+ b[9+msc->seglen] = (crc & 0xFF00) >> 8; // HI CRC
+ b[9+msc->seglen+1] = crc & 0x00FF; // LO CRC
+
+ *bsize=9+msc->seglen+1+1;
+
+ //write(1,b,9+msc->seglen+1+1);
+
+}
+
+
+void writeMotPAD(unsigned char* mscdg, unsigned short int mscdgsize, unsigned short int padlen) {
+
+ unsigned char pad[128];
+ int xpadlengthmask,i,j,numseg,lastseglen;
+ unsigned short int crc;
+
+
+ if (padlen==17)
+ xpadlengthmask=3;
+ else if (padlen==21)
+ xpadlengthmask=4;
+ else if (padlen==29)
+ xpadlengthmask=5;
+ else if (padlen==37)
+ xpadlengthmask=6;
+ else if (padlen==53)
+ xpadlengthmask=7;
+
+
+ // Write Data Group Length Indicator
+ crc = 0xffff;
+ pad[padlen-1]=0x02; // FF-PAD Byte L (CI=1)
+ pad[padlen-2]=0x20; // FF-PAD Byte L-1 (Variable size X_PAD)
+ pad[padlen-3]=(xpadlengthmask<<5) | 0x01; // CI => data length = 12 (011) - Application Type=2 (DLS - start of X-PAD data group)
+ pad[padlen-4]=0x00; // End of CI list
+ pad[padlen-5]=(mscdgsize & 0x3F00)>>8; // RFA+HI Data group length
+ pad[padlen-6]=(mscdgsize & 0x00FF);
+ crc = update_crc_ccitt(crc, pad[padlen-5]);
+ crc = update_crc_ccitt(crc, pad[padlen-6]);
+ crc = ~crc;
+ pad[padlen-7]=(crc & 0xFF00) >> 8; // HI CRC
+ pad[padlen-8]=(crc & 0x00FF); // LO CRC
+ for (i=padlen-9;i>=0;i--) { // NULL PADDING
+ pad[i]=0x00;
+ }
+ write(STDOUT_FILENO,pad,padlen);
+ //fprintf(stderr,"Data Group Length Indicator: ");
+ //for (i=0;i<padlen;i++) fprintf(stderr,"%02x ",pad[i]);
+ //fprintf(stderr,"\n");
+
+ // Write MSC Data Groupsd
+ numseg=mscdgsize / (padlen-5);
+ lastseglen=mscdgsize % (padlen-5);
+ if (lastseglen > 0) {
+ numseg++; // The last incomplete segment
+ }
+
+ for (i=0;i<numseg;i++) {
+
+ char* curseg;
+ int curseglen;
+ UCHAR firstseg;
+
+ curseg = &mscdg[i*(padlen-5)];
+ //fprintf(stderr,"Segment number %d\n",i+1);
+
+ if (i==0) // First segment
+ firstseg=1;
+ else
+ firstseg=0;
+
+ if (i==numseg-1) { //Last segment
+ if (lastseglen!=0)
+ curseglen=lastseglen;
+ else
+ curseglen=padlen-5;
+ } else {
+ curseglen=padlen-5;
+ }
+
+ pad[padlen-1]=0x02; // FF-PAD Byte L (CI=1)
+ pad[padlen-2]=0x20; // FF-PAD Byte L-1 (Variable size X_PAD)
+ if (firstseg==1)
+ pad[padlen-3]=(xpadlengthmask<<5) | 12; // CI => data length = 12 (011) - Application Type=12 (start of MOT)
+ else
+ pad[padlen-3]=(xpadlengthmask<<5) | 13; // CI => data length = 12 (011) - Application Type=13 (MOT)
+
+ pad[padlen-4]=0x00; // End of CI list
+
+ for (j=0; j<curseglen; j++)
+ pad[padlen-5-j]=curseg[j];
+ for (j=padlen-5-curseglen;j>=0;j--)
+ pad[j]=0x00;
+
+ write(STDOUT_FILENO,pad,padlen);
+ //fprintf(stderr,"MSC Data Group - Segment %d: ",i);
+ //for (j=0;j<padlen;j++) fprintf(stderr,"%02x ",pad[j]);
+ // fprintf(stderr,"\n");
+
+ }
+}
+
+
+void writeDLS(int padlen) {
+ char dlstext[MAXDLS];
+ static char dlstextprev[MAXDLS];
+ int dlslen,i;
+ static unsigned char** dlsdg;
+ static int numdg=0;
+
+ static int dlsfd=0;
+
+ if (dlsfd!=0) close(dlsfd);
+ dlsfd=open("/tmp/dls.file",O_RDONLY);
+ if (dlsfd==-1) {
+ fprintf(stderr,"Error - Cannot open dls file\n");
+ return;
+ }
+
+ dlslen=read(dlsfd, dlstext, MAXDLS);
+ dlstext[dlslen]=0x00;
+ //if (strcmp(dlstext,dlstextprev)!=0) {
+ create_dls_datagroup(dlstext,padlen,&dlsdg,&numdg);
+ strcpy(dlstextprev,dlstext);
+ //}
+ for (i=0;i<numdg;i++) {
+ write(STDOUT_FILENO,dlsdg[i],padlen);
+ }
+
+}
+
+void create_dls_datagroup (char* text, int padlen, UCHAR*** p_dlsdg, int* p_numdg) {
+
+ UCHAR dlsseg[8][16]; // max 8 segments, each max 16 chars
+ UCHAR** dlsdg; // Array od datagroups composing dls text;
+
+
+ int numseg; // Number of DSL segments
+ int lastseglen; // Length of the last segment
+ int numdg; // Number of data group
+ int xpadlengthmask;
+ int i,j,k,z,idx_start_crc,idx_stop_crc;
+ USHORT dlscrc;
+ static UCHAR toggle=0;
+
+ if (toggle==0)
+ toggle=1;
+ else
+ toggle=0;
+
+ numseg=strlen(text) / 16;
+ lastseglen=strlen(text) % 16;
+ if (padlen-9 >= 16) {
+ if (lastseglen > 0) numseg++; // The last incomplete segment
+ numdg=numseg; // The PAD can contain the full segmnet and overhead (9 bytes)
+ } else {
+ numdg=numseg*2; // Each 16 char segment span over 2 dg
+ if (lastseglen > 0) {
+ numseg++; // The last incomplete segment
+ if (lastseglen <= padlen-9)
+ numdg+=1;
+ else
+ numdg+=2;
+
+ }
+ }
+ *p_numdg=numdg;
+ fprintf(stderr,"PAD Length: %d\n",padlen);
+ fprintf(stderr,"DLS text: %s\n",text);
+ fprintf(stderr,"Number od DLS segments: %d\n",numseg);
+ fprintf(stderr,"Number od DLS data grupus: %d\n",numdg);
+
+ if (padlen==17)
+ xpadlengthmask=3;
+ else if (padlen==21)
+ xpadlengthmask=4;
+ else if (padlen==29)
+ xpadlengthmask=5;
+ else if (padlen==37)
+ xpadlengthmask=6;
+ else if (padlen==53)
+ xpadlengthmask=7;
+
+ *p_dlsdg = (UCHAR**) malloc(numdg*sizeof(UCHAR*));
+ dlsdg=*p_dlsdg;
+
+ i=0;
+ for (z=0;z<numseg;z++) {
+
+ char* curseg;
+ int curseglen;
+ UCHAR firstseg,lastseg;
+
+ curseg = &text[z*16];
+ fprintf(stderr,"Segment number %d\n",z+1);
+
+ if (z==0) // First segment
+ firstseg=1;
+ else
+ firstseg=0;
+
+ if (z==numseg-1) { //Last segment
+ if (lastseglen!=0)
+ curseglen=lastseglen;
+ else
+ curseglen=16;
+ lastseg=1;
+ } else {
+ curseglen=16;
+ lastseg=0;
+ }
+
+ if (curseglen<=padlen-9) { // Segment is composed by 1 data group
+ dlsdg[i]=(UCHAR*) malloc(padlen*sizeof(UCHAR));
+ dlsdg[i][padlen-1]=0x02; // FF-PAD Byte L (CI=1)
+ dlsdg[i][padlen-2]=0x20; // FF-PAD Byte L-1 (Variable size X_PAD)
+ dlsdg[i][padlen-3]=(xpadlengthmask<<5) | 0x02; // CI => data length = 12 (011) - Application Type=2 (DLS - start of X-PAD data group)
+ dlsdg[i][padlen-4]=0x00; // End of CI list
+
+ dlsdg[i][padlen-5]=((toggle*8+firstseg*4+lastseg*2+0)<<4) | (curseglen-1); // DLS Prefix (T=1,Only one segment,segment length-1)
+
+ if (firstseg==1)
+ dlsdg[i][padlen-6]=0x00; // DLS Prefix (Charset standard)
+ else
+ dlsdg[i][padlen-6]=z<<4; // DLS SegNum
+
+ idx_start_crc = padlen-5; // CRC start from prefix
+ for (j=0;j<curseglen;j++) { // DLS text
+ dlsdg[i][padlen-7-j]=curseg[j];
+ }
+
+ idx_stop_crc = padlen-7-curseglen+1;
+
+ dlscrc = 0xffff;
+ for (j=idx_start_crc;j>=idx_stop_crc;j--) {
+ dlscrc = update_crc_ccitt(dlscrc, dlsdg[i][j]);
+ }
+
+ dlscrc = ~dlscrc;
+ fprintf(stderr,"crc=%x ~crc=%x\n",~dlscrc,dlscrc);
+
+ dlsdg[i][padlen-7-curseglen] = (dlscrc & 0xFF00) >> 8; // HI CRC
+ dlsdg[i][padlen-7-curseglen-1] = dlscrc & 0x00FF; // LO CRC
+
+ for (j=padlen-7-curseglen-2;j>=0;j--) { // NULL PADDING
+ dlsdg[i][j]=0x00;
+ }
+ fprintf(stderr,"Data group: ");
+ for (j=0;j<padlen;j++) fprintf(stderr,"%x ",dlsdg[i][j]);
+ fprintf(stderr,"\n");
+ i++;
+
+ } else { // Segment is composed by 2 data groups
+
+ // FIRST DG (NO CRC)
+ dlscrc = 0xffff;
+
+ dlsdg[i]=(UCHAR*) malloc(padlen*sizeof(UCHAR));
+ dlsdg[i][padlen-1]=0x02; // FF-PAD Byte L (CI=1)
+ dlsdg[i][padlen-2]=0x20; // FF-PAD Byte L-1 (Variable size X_PAD)
+ dlsdg[i][padlen-3]=(xpadlengthmask<<5) | 0x02; // CI => data length = 12 (011) - Application Type=2 (DLS - start of X-PAD data group)
+ dlsdg[i][padlen-4]=0x00; // End of CI list
+ dlsdg[i][padlen-5]=((toggle*8+firstseg*4+lastseg*2+0)<<4) | (curseglen-1); // DLS Prefix (T=1,Only one segment,segment length-1)
+
+ if (firstseg==1)
+ dlsdg[i][padlen-6]=0x00; // DLS Prefix (Charset standard)
+ else
+ dlsdg[i][padlen-6]=(i-1)<<4; // DLS SegNum
+
+ dlscrc = update_crc_ccitt(dlscrc, dlsdg[i][padlen-5]);
+ dlscrc = update_crc_ccitt(dlscrc, dlsdg[i][padlen-6]);
+
+ for (j=0;j < MIN(curseglen,padlen-7); j++) { // DLS text
+ dlsdg[i][padlen-7-j]=curseg[j];
+ dlscrc = update_crc_ccitt(dlscrc, dlsdg[i][padlen-7-j]);
+ }
+ k=j;
+ if (curseglen==padlen-8) { // end of segment
+ dlscrc = ~dlscrc;
+ dlsdg[i][1] = (dlscrc & 0xFF00) >> 8; // HI CRC
+ fprintf(stderr,"crc=%x ~crc=%x\n",~dlscrc,dlscrc);
+ } else if (curseglen==padlen-7) {
+ dlscrc = ~dlscrc;
+ fprintf(stderr,"crc=%x ~crc=%x\n",~dlscrc,dlscrc);
+ }
+ dlsdg[i][0]=0x00;
+
+ fprintf(stderr,"First Data group: ");
+ for (j=0;j<padlen;j++) fprintf(stderr,"%x ",dlsdg[i][j]);
+ fprintf(stderr,"\n");
+
+ // SECOND DG (NO CI, NO PREFIX)
+ i++;
+
+ dlsdg[i]=(UCHAR*) malloc(padlen*sizeof(UCHAR));
+ dlsdg[i][padlen-1]=0x00; // FF-PAD Byte L (CI=0)
+ dlsdg[i][padlen-2]=0x20; // FF-PAD Byte L-1 (Variable size X_PAD)
+ if (curseglen==padlen-8) {
+ dlsdg[i][padlen-3] = dlscrc & 0x00FF; // LO CRC
+ } else if (curseglen==padlen-7) {
+ dlsdg[i][padlen-3] = (dlscrc & 0xFF00) >> 8; // HI CRC
+ dlsdg[i][padlen-4] = dlscrc & 0x00FF; // LO CRC
+ } else {
+ for (j=0;j < curseglen-k; j++) { // DLS text
+ dlsdg[i][padlen-3-j]=curseg[k+j];
+ dlscrc = update_crc_ccitt(dlscrc, dlsdg[i][padlen-3-j]);
+ }
+ dlscrc = ~dlscrc;
+ dlsdg[i][padlen-3-curseglen+k]=(dlscrc & 0xFF00) >> 8; // HI CRC
+ dlsdg[i][padlen-3-curseglen+k-1]=dlscrc & 0x00FF; // LO CRC
+ }
+
+ fprintf(stderr,"Second Data group: ");
+ for (j=0;j<padlen;j++) fprintf(stderr,"%x ",dlsdg[i][j]);
+ fprintf(stderr,"\n");
+ fprintf(stderr,"**** crc=%x ~crc=%x\n",~dlscrc,dlscrc);
+ i++;
+ }
+
+ }
+}
+
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-25 18:01:10 +0000