Move sources to src, rename all programs

1 files changed, 638 insertions, 0 deletions

diff --git a/src/mot-encoder.c b/src/mot-encoder.c
new file mode 100644
index 0000000..a60a39a
--- /dev/null
+++ b/src/mot-encoder.c
@@ -0,0 +1,638 @@
+/*
+    Copyright (C) 2014 CSP Innovazione nelle ICT s.c.a r.l. (http://rd.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://rd.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++;
+        }
+
+    }
+}
+