source: ether_iasi_L1C/trunk/bufr.cpp @ 27

Last change on this file since 27 was 27, checked in by cbipsl, 17 years ago

validation creation appli extraction L1C
  • Property svn:eol-style set to native
  • Property svn:executable set to *
File size: 45.6 KB
Line 
1/*
2$Id: BUFR.cpp,v 1.5 2007/02/19 12:53:34 dhurtma Exp $
3$Id: BUFR.cpp,v 1.6 2007/06/10 cboonne $
4*/
5#include <stdlib.h>
6#include <stdio.h>
7#include <string.h>
8#include <memory.h>
9#include <math.h>
10#include <time.h>
11
12// Usefull Window Definitions
13typedef unsigned char       BYTE;
14typedef unsigned short      WORD;
15typedef unsigned long       DWORD,DWORD_PTR,LONG;
16
17#define BOOL  bool
18#define TRUE  1
19#define FALSE 0
20#define MAX_PATH 260
21
22#define MAKEWORD(a, b)      ((WORD)(((BYTE)((DWORD_PTR)(a) & 0xff)) | ((WORD)((BYTE)((DWORD_PTR)(b) & 0xff))) << 8))
23#define MAKELONG(a, b)      ((LONG)(((WORD)((DWORD_PTR)(a) & 0xffff)) | ((DWORD)((WORD)((DWORD_PTR)(b) & 0xffff))) << 16))
24#define LOWORD(l)           ((WORD)((DWORD_PTR)(l) & 0xffff))
25#define HIWORD(l)           ((WORD)((DWORD_PTR)(l) >> 16))
26#define LOBYTE(w)           ((BYTE)((DWORD_PTR)(w) & 0xff))
27#define HIBYTE(w)           ((BYTE)((DWORD_PTR)(w) >> 8))
28
29
30
31unsigned long convert24_32(unsigned char *lpData)
32{
33 unsigned long l_data;
34
35 l_data=lpData[0];
36 l_data=(l_data<<8)+lpData[1];
37 l_data=(l_data<<8)+lpData[2];
38
39 return l_data;
40}
41
42unsigned short convert16_16(unsigned char *lpData)
43{
44 unsigned short l_data;
45
46 l_data=lpData[0];
47 l_data=(l_data<<8)+lpData[1];
48
49 return l_data;
50}
51
52typedef struct _bufr_section_ptrs
53{
54 long p0;
55 long p1;
56 long p2;
57 long p3;
58 long p4;
59 long p5;
60} SECTION_PTR;
61
62typedef struct bufr_section_0
63{
64 char BUFR[4];
65 static const unsigned long length=8;
66 unsigned long FileLength;
67 unsigned char edition; 
68} SECTION_0,*LPSECTION_0;
69
70typedef enum
71{
72 DC_Surface_Land=0,
73 DC_Surface_Sea,
74 DC_Vertical,
75 DC_Vertical_Satellite,
76 DC_Single_Level_Upper,
77 DC_Single_Level_Upper_Satellite,
78 DC_Surface_Satellite=12,
79 DC_Oceanographic=31 
80} DATA_CATEGORY;
81
82typedef struct bufr_section_1
83{
84 unsigned long  length;
85 unsigned char  Master_Table_Number;
86 unsigned char  Sub_Centre;
87 unsigned char  Centre;
88 unsigned char  Update_Sequence;
89 bool           bOptional;
90 DATA_CATEGORY  Data_Category;
91 unsigned char  Data_Sub_Category;
92 unsigned char  Master_Table_Version;
93 unsigned char  Local_Table_Version;
94 unsigned short Year;
95 unsigned char  Month;
96 unsigned char  Day;
97 unsigned char  Hour;
98 unsigned char  Minute;
99 unsigned char *lpADP_Reserved;
100} SECTION_1,*LPSECTION_1;
101
102typedef struct bufr_section_2
103{
104 unsigned long  length;
105 unsigned char  dummy;
106 unsigned char *lpADP_Reserved; 
107} SECTION_2,*LPSECTION_2;
108
109typedef struct bufr_descriptor
110{
111 unsigned char X : 6;  // F=0,3 Class; F=1 # of parameters, F=2 
112 unsigned char F : 2;  // 0 --> Element Table B, 1 --> Replicator, 2 --> Operator Table C, 3 --> Sequence Table D
113 unsigned char Y;      // F=0,3 Entry within class, F=1 times to replicate if 0 read in data
114} DESCRIPTOR,*LPDESCRIPTOR;
115 
116typedef struct bufr_section_3
117{
118 unsigned long  length;
119 unsigned char  dummy;
120 unsigned short Number_Subsets;
121 bool           bObserved;
122 bool           bCompressed;
123 unsigned long  Number_Descriptors;
124 LPDESCRIPTOR   lpDescriptors;
125} SECTION_3,*LPSECTION_3;
126
127typedef struct bufr_section_4
128{
129 unsigned long  length;
130 unsigned char  dummy;
131 unsigned char *lpData;
132} SECTION_4,*LPSECTION_4;
133
134typedef struct bufr_3_40_002
135{
136 unsigned short Start_Channel;            // 14 bits
137 unsigned short End_Channel;              // 14 bits
138 unsigned char  Channel_Scale_Factor;     //  6 bits
139}DESCR_3_40_002;
140
141typedef struct bufr_3_40_003
142{
143 unsigned short Channel_Number[100];         // 14 bits
144 unsigned short Scaled_Iasi_Radiance[100];// 16 bits
145}DESCR_3_40_003;
146
147typedef struct bufr_3_40_004
148{
149 unsigned long Y_angular_position;        // 24 bits
150 unsigned long Z_angular_position;        //    24 bits
151 unsigned char Fraction_clear_pixels_HIRS;//    7 bits
152
153 unsigned char Channel_Number[6];               //      6 bits
154 unsigned char Channel_Scale_Factor_1[6];       //      6 bits
155 unsigned long Scaled_Mean_AVHRR_Rad[6];        // 31 bits
156 unsigned char Channel_Scale_Factor_2[6];       //      6 bits
157 unsigned long Scaled_Std_AVHRR_Rad[6];   // 31 bits
158}DESCR_3_40_004;
159
160typedef struct bufr_3_40_001
161{
162 unsigned short Satellite_Identifier;     // 10 bits 
163 unsigned short Originating_Centre;       // 16 bits 
164 unsigned short Satellite_Instruments_1;  // 11 bits 
165 unsigned short Satellite_Classification; //  9 bits 
166 unsigned short Year;                     // 12 bits
167 unsigned char  Month;                    //  4 bits
168 unsigned char  Day;                      //  6 bits
169 unsigned char  Hour;                     //  5 bits
170 unsigned char  Minute;                   //  6 bits
171 unsigned short Second;                   //    16 bits
172 unsigned long  Latitude;                 //    25 bits
173 unsigned long  Longitude;                //    26 bits
174 unsigned short Satellite_Zenith_Angle;   // 15 bits
175 unsigned short Azimuth;                  //    16 bits
176 unsigned short Solar_Zenith_Angle;       // 15 bits
177 unsigned short Solar_Azimuth;            //    16 bits
178 unsigned char  FOV_Number;               //    8 bits
179 unsigned long  Orbit_Number;             //    24 bits
180 unsigned short Scan_Line_Number;         //    13 bits
181 unsigned char  Major_Frame_Count;        //    8 bits
182 unsigned short Height_of_Station;             //       15 bits
183 unsigned char  GQisFlagQual;               //          2 bits
184 unsigned char  QGisQualIndex;             //           7 bits
185 unsigned char  QGisQualIndexLoc;               //              7 bits
186 unsigned char  QGisQualIndexRad;               //              7 bits
187 unsigned char  QGisQualIndexSpect;           //                7 bits
188 unsigned long  GQisQualIndexTexSondQual;       //      24 bits
189 DESCR_3_40_002 Band_Description[10];
190 DESCR_3_40_003 Channels_Sequence[87];
191 unsigned short Satellite_Instruments_2;  // 11 bits
192 unsigned char  AVHRR_channel_combination;//  7 bits
193 DESCR_3_40_004 AVHRR_Scene_Sequence[7];   
194}DESCR_3_40_001;
195
196typedef struct iasi_amp
197{
198 char          szMagic[16];               // AMP_IASI_V1
199 double        date;
200 double        Latitude;
201 double        Longitude;
202 unsigned char QualFlag;
203 double        Satellite_Zenith_Angle;
204 double        Azimuth;
205 double        Solar_Zenith_Angle;
206 double        Solar_Azimuth;
207 unsigned long Orbit_Number;
208 double        Height_of_Station;
209 double        Cloud_Free_Fraction[7];
210 double        AVHRR_Mean[6][7];
211 double        AVHRR_Std[6][7];
212 double        nu_start;
213 double        nu_end;
214 long          nbp; 
215 double        Radiance[8700];
216} IASI_AMP,*LPIASI_AMP;
217
218IASI_AMP      specs[120];
219
220BOOL ProcessCompressedIasiLevel1CData(SECTION_1 s1,SECTION_3 s3,SECTION_4 s4,LPIASI_AMP specs);
221
222void bufr_parse_section_4(unsigned char *lpData,SECTION_4 &s4)
223{
224 unsigned short offset=3;
225 unsigned long  length_Data;
226 
227 s4.length=convert24_32(lpData); 
228 s4.dummy=lpData[offset++];
229 length_Data=s4.length-offset;
230
231 s4.lpData=(unsigned char*)malloc(length_Data);
232 memcpy(s4.lpData,lpData+offset,length_Data);
233}
234
235void bufr_free_s4(SECTION_4 &s4)
236{
237 if (s4.lpData)
238    free(s4.lpData);
239}
240
241void bufr_parse_section_3(unsigned char *lpData,SECTION_3 &s3)
242{
243 unsigned short offset=3;
244 unsigned long  length_Descriptor;
245 
246 s3.length=convert24_32(lpData); 
247 s3.dummy=lpData[offset++];
248 s3.Number_Subsets=convert16_16(lpData+offset)  ;
249 offset=6;
250 s3.bObserved=((lpData[offset]&128)==128);
251 s3.bCompressed=((lpData[offset]&64)==64);
252 offset=7;
253 length_Descriptor=s3.length-offset;
254 s3.Number_Descriptors=length_Descriptor/2;
255 s3.lpDescriptors=(LPDESCRIPTOR)malloc(length_Descriptor);
256 memcpy(s3.lpDescriptors,lpData+offset,length_Descriptor);
257}
258
259void bufr_free_s3(SECTION_3 &s3)
260{
261 if (s3.lpDescriptors)
262    free(s3.lpDescriptors);
263}
264
265void bufr_parse_section_2(unsigned char *lpData,SECTION_2 &s2)
266{
267 unsigned short offset=4;
268 unsigned long  length_Reserved;
269
270 s2.length=convert24_32(lpData); 
271 s2.dummy=lpData[3]; 
272 length_Reserved=s2.length-offset;
273 s2.lpADP_Reserved=(unsigned char*)malloc(length_Reserved);
274 memcpy(s2.lpADP_Reserved,lpData+offset,length_Reserved);
275}
276
277void bufr_free_s2(SECTION_2 &s2)
278{
279 if (s2.lpADP_Reserved)
280    free(s2.lpADP_Reserved);
281}
282
283void bufr_parse_section_1(unsigned char *lpData,SECTION_1 &s1)
284{
285 unsigned short offset=3;
286 unsigned long  length_Reserved;
287
288 s1.length=convert24_32(lpData); 
289 s1.Master_Table_Number=lpData[offset++];
290 s1.Sub_Centre=lpData[offset++];
291 s1.Centre=lpData[offset++];
292 s1.Update_Sequence=lpData[offset++];
293 s1.bOptional=((lpData[offset++]&128)==128);
294 s1.Data_Category=(DATA_CATEGORY)lpData[offset++];
295 s1.Data_Sub_Category=lpData[offset++];
296 s1.Master_Table_Version=lpData[offset++];
297 s1.Local_Table_Version=lpData[offset++];
298 s1.Year=2000+lpData[offset++];
299 s1.Month=lpData[offset++];
300 s1.Day=lpData[offset++];
301 s1.Hour=lpData[offset++];
302 s1.Minute=lpData[offset++];
303 length_Reserved=s1.length-offset;
304 s1.lpADP_Reserved=(unsigned char*)malloc(length_Reserved);
305 memcpy(s1.lpADP_Reserved,lpData+offset,length_Reserved);
306}
307
308void bufr_free_s1(SECTION_1 &s1)
309{
310 if (s1.lpADP_Reserved)
311    free(s1.lpADP_Reserved);
312}
313
314void bufr_parse_section_0(unsigned char *lpData,SECTION_0 &s0)
315{
316 memcpy(s0.BUFR,lpData,4);
317 s0.FileLength=convert24_32(lpData+4); 
318 s0.edition=lpData[7];
319}
320
321int main(int argc, char* argv[])
322{
323 FILE *fin;
324 unsigned char *lpData;
325 unsigned long DataAllocated;
326 unsigned long length;
327 SECTION_0     s0={0};
328 SECTION_1     s1={0};
329 SECTION_2     s2={0};
330 SECTION_3     s3={0};
331 SECTION_4     s4={0};
332 long          it=0;
333 long          filelength;
334 unsigned long i,j,k;
335 SECTION_PTR   sp;
336 BOOL          bAnswer;
337
338
339 fin=fopen(argv[1],"rb");
340
341 DataAllocated=8;
342 lpData=(unsigned char*)malloc(DataAllocated);
343 fseek(fin,0,SEEK_END);
344 filelength=ftell(fin);
345 sp.p0=0; 
346
347L_AGAIN:
348 it++;
349 // Add preamble
350 sp.p0+=34; //Orbit, hour,...?
351 // Section 0
352 if (fseek(fin,sp.p0,SEEK_SET)>0)
353    goto L_FIN;
354 // Section 0 is always 8 bytes long
355 length=8;
356 // Read & parse
357 if (fread(lpData,length,1,fin)<1)
358    goto L_FIN;
359 bufr_parse_section_0(lpData,s0);
360 sp.p1=sp.p0+s0.length;
361
362 // Section 1
363 fseek(fin,sp.p1,SEEK_SET);
364 // Get length
365 fread(lpData,3,1,fin);
366 length=convert24_32(lpData);
367 // Reallocate buffer if needed
368 if (length>DataAllocated)
369   {
370    DataAllocated=length;
371    lpData=(unsigned char*)realloc(lpData,length);
372   }
373 // Read & parse
374 fseek(fin,sp.p1,SEEK_SET);
375 fread(lpData,length,1,fin);
376 bufr_parse_section_1(lpData,s1);
377 if (s1.bOptional)
378   {
379    sp.p2=sp.p1+s1.length;
380
381    // Section 2
382    fseek(fin,sp.p2,SEEK_SET);
383
384    // Get length
385    fread(lpData,3,1,fin);
386    length=convert24_32(lpData);
387    // Reallocate buffer if needed
388    if (length>DataAllocated)
389      {
390       DataAllocated=length;
391       lpData=(unsigned char*)realloc(lpData,length);
392      }
393    // Read & parse
394    fseek(fin,sp.p2,SEEK_SET);
395    fread(lpData,length,1,fin);
396    bufr_parse_section_2(lpData,s2);
397
398    sp.p3=sp.p2+s2.length;
399   }
400 else
401   {
402    sp.p2=-1;
403    sp.p3=sp.p1+s1.length;
404   }
405
406 // Section 3
407 fseek(fin,sp.p3,SEEK_SET);
408 // Get length
409 fread(lpData,3,1,fin);
410 length=convert24_32(lpData);
411 // Reallocate buffer if needed
412 if (length>DataAllocated)
413   {
414    DataAllocated=length;
415    lpData=(unsigned char*)realloc(lpData,length);
416   }
417 // Read & parse
418 fseek(fin,sp.p3,SEEK_SET);
419 fread(lpData,length,1,fin);
420 bufr_parse_section_3(lpData,s3);
421 sp.p4=sp.p3+s3.length;
422
423 // Section 4
424 fseek(fin,sp.p4,SEEK_SET);
425 // Get length
426 fread(lpData,3,1,fin);
427 length=convert24_32(lpData);
428
429 // Reallocate buffer if needed
430 if (length>DataAllocated)
431   {
432    DataAllocated=length;
433    lpData=(unsigned char*)realloc(lpData,length);
434   }
435
436 // Read & parse
437 fseek(fin,sp.p4,SEEK_SET);
438 memset(lpData,0xff,length);
439
440 fread(lpData,1,length,fin);
441 
442 bufr_parse_section_4(lpData,s4);
443 sp.p5=sp.p4+s4.length;
444
445/*
446 for (i=0;i<s3.Number_Descriptors;++i)
447    {
448     printf ("%.2d:%.2d => %.1d %.2d %.3d\n",it,i,s3.lpDescriptors[i].F,s3.lpDescriptors[i].X,s3.lpDescriptors[i].Y);
449    }
450*/
451 
452 //Check section 5 is 7777
453 fseek(fin,sp.p5,SEEK_SET);
454 fread(lpData,4,1,fin);
455 if (strncmp((char*)lpData,"7777",4)!=0)
456    printf("Error\n");
457     
458 // Process lpdata
459 bAnswer=ProcessCompressedIasiLevel1CData(s1,s3,s4,specs);
460/*
461 if (bAnswer)
462     printf("AVHRR status  : Seems OK\n");
463 else
464     printf("AVHRR status  : Seems Corrupt\n");
465*/
466 
467 // Save spectra...
468 for (k=0;k<120;++k)
469    {
470     char szFName[MAX_PATH];
471     FILE *fSpec;
472
473     sprintf(szFName,"%15.6lf_%.3d_%.5d_%.5d.asc",specs[k].date,k+1,int((specs[k].Latitude+90)*100),int((specs[k].Longitude+180)*100));
474     fSpec=fopen(szFName,"w");
475
476     fprintf(fSpec,"==========================================================\n");
477     {
478      struct tm   *newTime;
479      time_t      szClock;
480
481      // Get time in seconds
482      time( &szClock );
483
484      // Convert time to struct tm form
485      newTime = localtime( &szClock );
486
487      // Note: asctime is deprecated; consider using asctime_s instead
488      fprintf(fSpec,"IASI file converted on %s", asctime(newTime)) ;
489     }
490
491     fprintf(fSpec,"==========================================================\n");
492     fprintf(fSpec,"%15.9lf : Date\n",specs[k].date);
493     fprintf(fSpec,"%.08d : Orbit Number\n",specs[k].Orbit_Number);
494     switch (specs[k].QualFlag)
495           {
496            case 0:
497                fprintf(fSpec,"good : Quality Flag\n");
498                break;
499            case 1:
500                fprintf(fSpec,"bad : Quality Flag\n");
501                break;
502            case 2:
503                fprintf(fSpec,"reserved : Quality Flag\n");
504                break;
505            case 3:
506                fprintf(fSpec,"missing : Quality Flag\n");
507                break;
508           }
509/*
510     if (bAnswer)
511         fprintf(fSpec,"AVHRR status  : Seems OK\n");
512     else
513         fprintf(fSpec,"AVHRR status  : Seems Corrupt\n");
514*/
515     printf("%+7.5lf,%+7.5lf,%5.2lf,%5.1lf,%15.9lf,%.08d,%s,%.1d\n",specs[k].Latitude,specs[k].Longitude,specs[k].Satellite_Zenith_Angle,
516            specs[k].Height_of_Station,specs[k].date,specs[k].Orbit_Number,szFName,specs[k].QualFlag);
517     fprintf(fSpec,"%+7.5lf : Latitude(?)\n",specs[k].Latitude);
518     fprintf(fSpec,"%+7.5lf : Longitude(?)\n",specs[k].Longitude);
519     fprintf(fSpec,"%5.2lf : Sat ZA(?)\n",specs[k].Satellite_Zenith_Angle);
520     fprintf(fSpec,"%5.2lf : Sat AZ(?)\n",specs[k].Azimuth);
521     fprintf(fSpec,"%5.2lf : Sun ZA(?)\n",specs[k].Solar_Zenith_Angle);
522     fprintf(fSpec,"%5.2lf : Sun AZ(?)\n",specs[k].Solar_Azimuth);
523     fprintf(fSpec,"%5.1lf : Altitude(km)\n",specs[k].Height_of_Station);
524     fprintf(fSpec," ");
525     for (i=0;i<7;++i)
526         fprintf(fSpec,"%+2.0lf ",specs[k].Cloud_Free_Fraction[i]);
527     fprintf(fSpec," : Cloud Free(%%)\n");
528     for (j=0;j<6;++j)
529        {
530         fprintf(fSpec,"AVHRR Pixel    : %.1d\n",j+1);
531         fprintf(fSpec,"      Mean     : ");
532         for (i=0;i<7;++i)
533             fprintf(fSpec,"%.4le ",specs[k].AVHRR_Mean[j][i]);
534         fprintf(fSpec,"\n");
535         fprintf(fSpec,"      Std      : ");
536         for (i=0;i<7;++i)
537             fprintf(fSpec,"%.4le ",specs[k].AVHRR_Std[j][i]);
538         fprintf(fSpec,"\n");
539        }
540 
541     fprintf(fSpec,"%7.2lf : nu start(cm-1)\n",specs[k].nu_start);
542     fprintf(fSpec,"%7.2lf : nu end(cm-1)\n",specs[k].nu_end);
543     fprintf(fSpec,"%.3d : nbp\n",specs[k].nbp);
544     fprintf(fSpec,"==========================================================\n");
545     for (int i=0;i<8700;++i)
546         fprintf(fSpec,"%+.4le\n",specs[k].Radiance[i]);
547     fclose(fSpec);         
548    } 
549
550 // Cleanup and free
551 bufr_free_s1(s1);
552 bufr_free_s2(s2);
553 bufr_free_s3(s3);
554 bufr_free_s4(s4);
555
556 sp.p0=sp.p5+4; // size of section 5
557 sp.p0+=4;      // End of message post bytes
558
559
560 if (sp.p0<filelength)
561   {
562    goto L_AGAIN;
563   }
564
565L_FIN:
566 free(lpData);
567 fclose(fin); 
568        return 0;
569}
570
571void GetNextBits(unsigned char *lpData,unsigned char NbBits,unsigned char ReturnSize,void* lpReturn,bool bReset=false)
572{
573 static long   BytePos;
574 static int    BitPos;
575 unsigned char ByteTempBuffer[5];
576 unsigned char *lpTempReturn;
577 int           nBytes;
578
579 if (bReset)
580   {
581    BytePos=0;
582    BitPos=0;
583    return;
584   } 
585 lpTempReturn=(unsigned char*)lpReturn;
586 memset(ByteTempBuffer,0,5*sizeof(unsigned char));
587 nBytes=(NbBits+BitPos)/8+((NbBits+BitPos)%8>0);
588 // Transfer from lpData to Buffer with byte reversing
589 for (int i=0;i<nBytes;++i)
590    {
591     ByteTempBuffer[i]=lpData[BytePos+i];
592    }
593 memset(lpReturn,0,ReturnSize);
594
595 // Mask
596 switch (nBytes)
597       {
598        case 1:
599            {
600             char           Shift_8;
601             unsigned char  Mask;
602             unsigned char  Work;
603
604             Shift_8=(8-BitPos)-NbBits;
605 
606             Mask=((unsigned char)1<<NbBits)-1;                  // Build the Mask (eg: 00111111 for 6 bits data)
607             Work=ByteTempBuffer[0];                             // Transfer data to Work
608             Work>>=Shift_8;                                     // Align bits to the window
609             Work&=Mask;                                         // Apply the mask
610             ByteTempBuffer[0]=Work;                             // Save Work back in buffer
611             break;
612            }
613
614        case 2:
615            {
616             char           Shift_16;
617             unsigned short Mask;
618             unsigned short Work;
619
620             Shift_16=(16-BitPos)-NbBits;
621
622             Mask=((unsigned short)1<<NbBits)-1;                  // Build the Mask
623             Work=MAKEWORD(ByteTempBuffer[1],ByteTempBuffer[0]);  // Transfer data to Work
624             Work>>=Shift_16;                                     // Align bits to the window
625             Work&=Mask;                                          // Apply the mask
626             ByteTempBuffer[0]=LOBYTE(Work);                      // Save Work back in buffer with proper "endianness"
627             ByteTempBuffer[1]=HIBYTE(Work);                     
628             break;
629            }
630
631        case 3:
632            {
633             char           Shift_24;
634             unsigned long  Mask;                                 // Work in 4 bytes as there is no 3 bytes types
635             unsigned long  Work;
636             unsigned short W1,W2;
637
638             Shift_24=(24-BitPos)-NbBits;
639
640             Mask=((unsigned long)1<<NbBits)-1;                   // Build the Mask
641             W2=MAKEWORD(ByteTempBuffer[2],ByteTempBuffer[1]);    // Transfer data to High Word of Work
642             W1=MAKEWORD(ByteTempBuffer[0],0);                    // Transfer data to Low Word of  Work
643             Work=MAKELONG(W2,W1);
644             Work>>=Shift_24;                                     // Align bits to the window
645             Work&=Mask;                                          // Apply the mask
646             W1=LOWORD(Work);
647             W2=HIWORD(Work);
648             ByteTempBuffer[0]=LOBYTE(W1);                        // Save Work back in buffer with proper "endianness"
649             ByteTempBuffer[1]=HIBYTE(W1);                     
650             ByteTempBuffer[2]=LOBYTE(W2);                     
651             ByteTempBuffer[3]=0;                     
652             break;
653            }
654
655        case 4:
656            {
657             char           Shift_32;
658             unsigned long  Mask;
659             unsigned long  Work;
660             unsigned short W1,W2;
661
662             Shift_32=(32-BitPos)-NbBits;
663
664             Mask=((unsigned long)1<<NbBits)-1;                   // Build the Mask
665             W2=MAKEWORD(ByteTempBuffer[3],ByteTempBuffer[2]);    // Transfer data to High Word of Work
666             W1=MAKEWORD(ByteTempBuffer[1],ByteTempBuffer[0]);    // Transfer data to Low Word of  Work
667             Work=MAKELONG(W2,W1);
668             Work>>=Shift_32;                                     // Align bits to the window
669             Work&=Mask;                                          // Apply the mask
670             W1=LOWORD(Work);
671             W2=HIWORD(Work);
672             ByteTempBuffer[0]=LOBYTE(W1);                        // Save Work back in buffer with proper "endianness"
673             ByteTempBuffer[1]=HIBYTE(W1);                     
674             ByteTempBuffer[2]=LOBYTE(W2);                     
675             ByteTempBuffer[3]=HIBYTE(W2);                     
676             break;
677            }
678
679        case 5:
680             unsigned char  Shift_40;
681             unsigned long  Mask;                                 // Use more than 4 bytes but store only on 4
682             unsigned long  Work;
683             unsigned char  WorkLSB;
684             unsigned char  ShiftLSB;
685             unsigned short W1,W2;
686
687             Shift_40=BitPos+NbBits-32;
688
689             Mask=((unsigned long)1<<NbBits)-1;                   // Build the Mask
690             ShiftLSB=7-Shift_40;
691
692             W2=MAKEWORD(ByteTempBuffer[3],ByteTempBuffer[2]);    // Transfer data to High Word of Work
693             W1=MAKEWORD(ByteTempBuffer[1],ByteTempBuffer[0]);    // Transfer data to Low Word of  Work
694             Work=MAKELONG(W2,W1);
695             Work<<=Shift_40;                                     // We work reverse here.
696             WorkLSB=ByteTempBuffer[4];
697             WorkLSB>>=ShiftLSB;
698             Work|=WorkLSB;                                       // Join the shifted LSB bits to Work
699             Work&=Mask;                                          // Apply the mask
700             W1=LOWORD(Work);
701             W2=HIWORD(Work);
702             ByteTempBuffer[0]=LOBYTE(W1);                        // Save Work back in buffer with proper "endianness"
703             ByteTempBuffer[1]=HIBYTE(W1);                     
704             ByteTempBuffer[2]=LOBYTE(W2);                     
705             ByteTempBuffer[3]=HIBYTE(W2);                     
706             break;
707       }
708 // Set return value
709 memcpy(lpTempReturn,ByteTempBuffer,ReturnSize);
710
711 // Update position
712 BitPos+=NbBits;
713 BytePos+=BitPos/8;
714 BitPos%=8;
715}
716
717BOOL ProcessCompressedIasiLevel1CData(SECTION_1 s1,SECTION_3 s3,SECTION_4 s4,LPIASI_AMP specs)
718{
719 unsigned char NbBits;
720 
721 DESCR_3_40_002 LocalChannel[120*10];
722 DESCR_3_40_001 LocalBufr;
723
724 for (int k=0;k<120;++k)
725    {
726     specs[k].nbp=8700;
727     specs[k].nu_start=645.;
728     specs[k].nu_end=2819.75;
729     strcpy(specs[k].szMagic,"AMP_IASI_V1");
730    }
731
732 GetNextBits(0,0,0,0,true);
733 GetNextBits(s4.lpData,10,sizeof(LocalBufr.Satellite_Identifier),&LocalBufr.Satellite_Identifier,false);
734 GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
735 if (NbBits>0)
736   {
737    for (long k=0;k<s3.Number_Subsets;++k)
738       {
739        unsigned short temp;
740        GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
741        temp+=LocalBufr.Satellite_Identifier;
742       }
743   }
744 else
745   {
746   }
747
748 GetNextBits(s4.lpData,16,sizeof(LocalBufr.Originating_Centre),&LocalBufr.Originating_Centre,false);
749 GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
750 if (NbBits>0)
751   {
752    for (long k=0;k<s3.Number_Subsets;++k)
753       {
754        unsigned short temp;
755        GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
756        temp+=LocalBufr.Originating_Centre;
757       }
758   }
759 else
760   {
761   }
762
763 GetNextBits(s4.lpData,11,sizeof(LocalBufr.Satellite_Instruments_1),&LocalBufr.Satellite_Instruments_1,false);
764 GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
765 if (NbBits>0)
766   {
767    for (long k=0;k<s3.Number_Subsets;++k)
768       {
769        unsigned short temp;
770        GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
771        temp+=LocalBufr.Satellite_Instruments_1;
772       }
773   }
774 else
775   {
776   }
777
778 GetNextBits(s4.lpData, 9,sizeof(LocalBufr.Satellite_Classification),&LocalBufr.Satellite_Classification,false); 
779 GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
780 if (NbBits>0)
781   {
782    for (long k=0;k<s3.Number_Subsets;++k)
783       {
784        unsigned short temp;
785        GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
786        temp+=LocalBufr.Satellite_Classification;
787       }
788   }
789 else
790   {
791   }
792
793 GetNextBits(s4.lpData,12,sizeof(LocalBufr.Year),&LocalBufr.Year,false); 
794 GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
795 if (NbBits>0)
796   {
797    for (long k=0;k<s3.Number_Subsets;++k)
798       {
799        unsigned short temp;
800        GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
801        temp+=LocalBufr.Year;
802        specs[k].date=temp*10000;
803       }
804   }
805 else
806   {
807    for (long k=0;k<s3.Number_Subsets;++k)
808        specs[k].date=LocalBufr.Year*10000;
809   }
810
811 GetNextBits(s4.lpData, 4,sizeof(LocalBufr.Month),&LocalBufr.Month,false); 
812 GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
813 if (NbBits>0)
814   {
815    for (long k=0;k<s3.Number_Subsets;++k)
816       {
817        unsigned char temp;
818        GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
819        temp+=LocalBufr.Month;
820        specs[k].date+=temp*100;
821       }
822   }
823 else
824   {
825    for (long k=0;k<s3.Number_Subsets;++k)
826        specs[k].date+=LocalBufr.Month*100;
827   }
828 GetNextBits(s4.lpData, 6,sizeof(LocalBufr.Day),&LocalBufr.Day,false); 
829 GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
830 if (NbBits>0)
831   {
832    for (long k=0;k<s3.Number_Subsets;++k)
833       {
834        unsigned char temp;
835        GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
836        temp+=LocalBufr.Day;
837        specs[k].date+=temp;
838       }
839   }
840 else
841   {
842    for (long k=0;k<s3.Number_Subsets;++k)
843        specs[k].date+=LocalBufr.Day;
844   }
845 GetNextBits(s4.lpData, 5,sizeof(LocalBufr.Hour),&LocalBufr.Hour,false); 
846 GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
847 if (NbBits>0)
848   {
849    for (long k=0;k<s3.Number_Subsets;++k)
850       {
851        unsigned char temp;
852        GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
853        temp+=LocalBufr.Hour;
854        specs[k].date+=temp/100.;
855       }
856   }
857 else
858   {
859    for (long k=0;k<s3.Number_Subsets;++k)
860        specs[k].date+=LocalBufr.Hour/100.;
861   }
862 GetNextBits(s4.lpData, 6,sizeof(LocalBufr.Minute),&LocalBufr.Minute,false); 
863 GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
864 if (NbBits>0)
865   {
866    for (long k=0;k<s3.Number_Subsets;++k)
867       {
868        unsigned char temp;
869        GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
870        temp+=LocalBufr.Minute;
871        specs[k].date+=temp/10000.;
872       }
873   }
874 else
875   {
876    for (long k=0;k<s3.Number_Subsets;++k)
877        specs[k].date+=LocalBufr.Minute/10000.;
878   }
879 GetNextBits(s4.lpData,16,sizeof(LocalBufr.Second),&LocalBufr.Second,false); 
880 GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
881 if (NbBits>0)
882   {
883    for (long k=0;k<s3.Number_Subsets;++k)
884       {
885        unsigned short temp;
886        GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
887        temp+=LocalBufr.Second;
888        specs[k].date+=temp/1e9;
889       }
890   }
891 else
892   {
893    for (long k=0;k<s3.Number_Subsets;++k)
894        specs[k].date+=LocalBufr.Second/1e9;
895   }
896
897 GetNextBits(s4.lpData,25,sizeof(LocalBufr.Latitude),&LocalBufr.Latitude,false); 
898 GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
899 if (NbBits>0)
900   {
901    for (long k=0;k<s3.Number_Subsets;++k)
902       {
903        unsigned long temp;
904        GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
905        temp+=LocalBufr.Latitude;
906        specs[k].Latitude=temp/1e5-90.;
907       }
908   }
909 else
910   {
911    for (long k=0;k<s3.Number_Subsets;++k)
912        specs[k].Latitude=LocalBufr.Latitude/1e5-90.;
913   }
914
915 GetNextBits(s4.lpData,26,sizeof(LocalBufr.Longitude),&LocalBufr.Longitude,false); 
916 GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
917 if (NbBits>0)
918   {
919    for (long k=0;k<s3.Number_Subsets;++k)
920       {
921        unsigned long temp;
922        GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
923        temp+=LocalBufr.Longitude;
924        specs[k].Longitude=temp/1e5-180.;
925       }
926   }
927 else
928   {
929    for (long k=0;k<s3.Number_Subsets;++k)
930        specs[k].Longitude=LocalBufr.Longitude/1e5-180.;
931   }
932
933 GetNextBits(s4.lpData,15,sizeof(LocalBufr.Satellite_Zenith_Angle),&LocalBufr.Satellite_Zenith_Angle,false); 
934 GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
935 if (NbBits>0)
936   {
937    for (long k=0;k<s3.Number_Subsets;++k)
938       {
939        unsigned short temp;
940        GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
941        temp+=LocalBufr.Satellite_Zenith_Angle;
942        specs[k].Satellite_Zenith_Angle=temp/100.-90.;
943       }
944   }
945 else
946   {
947    for (long k=0;k<s3.Number_Subsets;++k)
948        specs[k].Satellite_Zenith_Angle=LocalBufr.Satellite_Zenith_Angle/100.-90.;
949   }
950
951 GetNextBits(s4.lpData,16,sizeof(LocalBufr.Azimuth),&LocalBufr.Azimuth,false); 
952 GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
953 if (NbBits>0)
954   {
955    for (long k=0;k<s3.Number_Subsets;++k)
956       {
957        unsigned short temp;
958        GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
959        temp+=LocalBufr.Azimuth;
960        specs[k].Azimuth=temp/100.;
961       }
962   }
963 else
964   {
965    for (long k=0;k<s3.Number_Subsets;++k)
966        specs[k].Azimuth=LocalBufr.Azimuth/100.;
967   }
968
969 GetNextBits(s4.lpData,15,sizeof(LocalBufr.Solar_Zenith_Angle),&LocalBufr.Solar_Zenith_Angle,false); 
970 GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
971 if (NbBits>0)
972   {
973    for (long k=0;k<s3.Number_Subsets;++k)
974       {
975        unsigned short temp;
976        GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
977        temp+=LocalBufr.Solar_Zenith_Angle;
978        specs[k].Solar_Zenith_Angle=temp/100.-90.;
979       }
980   }
981 else
982   {
983    for (long k=0;k<s3.Number_Subsets;++k)
984        specs[k].Solar_Zenith_Angle=LocalBufr.Solar_Zenith_Angle/100.-90.;
985   }
986
987 GetNextBits(s4.lpData,16,sizeof(LocalBufr.Solar_Azimuth),&LocalBufr.Solar_Azimuth,false); 
988 GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
989 if (NbBits>0)
990   {
991    for (long k=0;k<s3.Number_Subsets;++k)
992       {
993        unsigned short temp;
994        GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
995        temp+=LocalBufr.Solar_Azimuth;
996        specs[k].Solar_Azimuth=temp/100.;
997       }
998   }
999 else
1000   {
1001    for (long k=0;k<s3.Number_Subsets;++k)
1002        specs[k].Solar_Azimuth=LocalBufr.Solar_Azimuth/100.;
1003   }
1004
1005 GetNextBits(s4.lpData, 8,sizeof(LocalBufr.FOV_Number),&LocalBufr.FOV_Number,false); 
1006 GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
1007 if (NbBits>0)
1008   {
1009    for (long k=0;k<s3.Number_Subsets;++k)
1010       {
1011        unsigned char temp;
1012        GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
1013        temp+=LocalBufr.FOV_Number;
1014       }
1015   }
1016 else
1017   {
1018   }
1019
1020 GetNextBits(s4.lpData,24,sizeof(LocalBufr.Orbit_Number),&LocalBufr.Orbit_Number,false); 
1021 GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
1022 if (NbBits>0)
1023   {
1024    for (long k=0;k<s3.Number_Subsets;++k)
1025       {
1026        unsigned long temp;
1027        GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
1028        temp+=LocalBufr.Orbit_Number;
1029        specs[k].Orbit_Number=temp;
1030       }
1031   }
1032 else
1033   {
1034    for (long k=0;k<s3.Number_Subsets;++k)
1035        specs[k].Orbit_Number=LocalBufr.Orbit_Number;
1036   }
1037
1038 GetNextBits(s4.lpData,13,sizeof(LocalBufr.Scan_Line_Number),&LocalBufr.Scan_Line_Number,false); 
1039 GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
1040 if (NbBits>0)
1041   {
1042    for (long k=0;k<s3.Number_Subsets;++k)
1043       {
1044        unsigned short temp;
1045        GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
1046        temp+=LocalBufr.Scan_Line_Number;
1047       }
1048   }
1049 else
1050   {
1051   }
1052
1053 GetNextBits(s4.lpData,8,sizeof(LocalBufr.Major_Frame_Count),&LocalBufr.Major_Frame_Count,false); 
1054 GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
1055 if (NbBits>0)
1056   {
1057    for (long k=0;k<s3.Number_Subsets;++k)
1058       {
1059        unsigned char temp;
1060        GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
1061        temp+=LocalBufr.Major_Frame_Count;
1062       }
1063   }
1064 else
1065   {
1066   }
1067
1068 GetNextBits(s4.lpData,15,sizeof(LocalBufr.Height_of_Station),&LocalBufr.Height_of_Station,false); 
1069 GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
1070 if (NbBits>0)
1071   {
1072    for (long k=0;k<s3.Number_Subsets;++k)
1073       {
1074        unsigned short temp;
1075        GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
1076        temp+=LocalBufr.Height_of_Station;
1077        specs[k].Height_of_Station=temp/10.-4.;
1078       }
1079   }
1080 else
1081   {
1082    for (long k=0;k<s3.Number_Subsets;++k)
1083        specs[k].Height_of_Station=LocalBufr.Height_of_Station/10.-4.;
1084   }
1085
1086 GetNextBits(s4.lpData, 2,sizeof(LocalBufr.GQisFlagQual),&LocalBufr.GQisFlagQual,false); 
1087 GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
1088 if (NbBits>0)
1089   {
1090    for (long k=0;k<s3.Number_Subsets;++k)
1091       {
1092        unsigned char temp;
1093        GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
1094        temp+=LocalBufr.GQisFlagQual;
1095        specs[k].QualFlag=temp;
1096       }
1097   }
1098 else
1099   {
1100    for (long k=0;k<s3.Number_Subsets;++k)
1101        specs[k].QualFlag=LocalBufr.GQisFlagQual;
1102   }
1103
1104 GetNextBits(s4.lpData, 7,sizeof(LocalBufr.QGisQualIndex),&LocalBufr.QGisQualIndex,false); 
1105 GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
1106 if (NbBits>0)
1107   {
1108    for (long k=0;k<s3.Number_Subsets;++k)
1109       {
1110        unsigned char temp;
1111        GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
1112        temp+=LocalBufr.QGisQualIndex;
1113       }
1114   }
1115 else
1116   {
1117   }
1118
1119 GetNextBits(s4.lpData, 7,sizeof(LocalBufr.QGisQualIndexLoc),&LocalBufr.QGisQualIndexLoc,false); 
1120 GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
1121 if (NbBits>0)
1122   {
1123    for (long k=0;k<s3.Number_Subsets;++k)
1124       {
1125        unsigned char temp;
1126        GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
1127        temp+=LocalBufr.QGisQualIndexLoc;
1128       }
1129   }
1130 else
1131   {
1132   }
1133
1134 GetNextBits(s4.lpData, 7,sizeof(LocalBufr.QGisQualIndexRad),&LocalBufr.QGisQualIndexRad,false); 
1135 GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
1136 if (NbBits>0)
1137   {
1138    for (long k=0;k<s3.Number_Subsets;++k)
1139       {
1140        unsigned char temp;
1141        GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
1142        temp+=LocalBufr.QGisQualIndexRad;
1143       }
1144   }
1145 else
1146   {
1147   }
1148 GetNextBits(s4.lpData, 7,sizeof(LocalBufr.QGisQualIndexSpect),&LocalBufr.QGisQualIndexSpect,false); 
1149 GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
1150 if (NbBits>0)
1151   {
1152    for (long k=0;k<s3.Number_Subsets;++k)
1153       {
1154        unsigned char temp;
1155        GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
1156        temp+=LocalBufr.QGisQualIndexSpect;
1157       }
1158   }
1159 else
1160   {
1161   }
1162 GetNextBits(s4.lpData,24,sizeof(LocalBufr.GQisQualIndexTexSondQual),&LocalBufr.GQisQualIndexTexSondQual,false); 
1163 GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
1164 if (NbBits>0)
1165   {
1166    for (long k=0;k<s3.Number_Subsets;++k)
1167       {
1168        unsigned long temp;
1169        GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
1170        temp+=LocalBufr.GQisQualIndexTexSondQual;
1171       }
1172   }
1173 else
1174   {
1175   }
1176
1177 for (int i=0;i<10;++i)
1178    {
1179     GetNextBits(s4.lpData,14,sizeof(LocalBufr.Band_Description[i].Start_Channel),&LocalBufr.Band_Description[i].Start_Channel,false); 
1180     GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
1181     if (NbBits>0)
1182       {
1183        for (long k=0;k<s3.Number_Subsets;++k)
1184           {
1185            unsigned short temp;
1186            GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
1187            temp+=LocalBufr.Band_Description[i].Start_Channel;
1188            LocalChannel[k*10+i].Start_Channel=temp;
1189           }
1190       }
1191     else
1192       {
1193        for (long k=0;k<s3.Number_Subsets;++k)
1194            LocalChannel[k*10+i].Start_Channel=LocalBufr.Band_Description[i].Start_Channel;
1195       }
1196
1197     GetNextBits(s4.lpData,14,sizeof(LocalBufr.Band_Description[i].End_Channel),&LocalBufr.Band_Description[i].End_Channel,false); 
1198     GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
1199     if (NbBits>0)
1200       {
1201        for (long k=0;k<s3.Number_Subsets;++k)
1202           {
1203            unsigned short temp;
1204            GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
1205            temp+=LocalBufr.Band_Description[i].End_Channel;
1206            LocalChannel[k*10+i].End_Channel=temp;
1207           }
1208       }
1209     else
1210       {
1211        for (long k=0;k<s3.Number_Subsets;++k)
1212            LocalChannel[k*10+i].End_Channel=LocalBufr.Band_Description[i].End_Channel;
1213       }
1214
1215     GetNextBits(s4.lpData, 6,sizeof(LocalBufr.Band_Description[i].Channel_Scale_Factor),&LocalBufr.Band_Description[i].Channel_Scale_Factor,false); 
1216     GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
1217     if (NbBits>0)
1218       {
1219        for (long k=0;k<s3.Number_Subsets;++k)
1220           {
1221            unsigned char temp;
1222            GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
1223            temp+=LocalBufr.Band_Description[i].Channel_Scale_Factor;
1224            LocalChannel[k*10+i].Channel_Scale_Factor=temp;
1225           }
1226       }
1227     else
1228       {
1229        for (long k=0;k<s3.Number_Subsets;++k)
1230            LocalChannel[k*10+i].Channel_Scale_Factor=LocalBufr.Band_Description[i].Channel_Scale_Factor;
1231       }
1232    }
1233
1234 for (int i=0;i<87;++i)
1235    {
1236     for (int j=0;j<100;++j)
1237        {
1238         GetNextBits(s4.lpData,14,sizeof(LocalBufr.Channels_Sequence[i].Channel_Number[j]),&LocalBufr.Channels_Sequence[i].Channel_Number[j],false); 
1239         GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
1240         if (NbBits>0)
1241           {
1242            for (long k=0;k<s3.Number_Subsets;++k)
1243               {
1244                unsigned short temp;
1245                GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
1246                temp+=LocalBufr.Channels_Sequence[i].Channel_Number[j];
1247               }
1248           }
1249         else
1250           {
1251           }
1252         GetNextBits(s4.lpData,16,sizeof(LocalBufr.Channels_Sequence[i].Scaled_Iasi_Radiance[j]),&LocalBufr.Channels_Sequence[i].Scaled_Iasi_Radiance[j],false); 
1253         GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
1254         if (NbBits>0)
1255           {
1256            for (long k=0;k<s3.Number_Subsets;++k)
1257               {
1258                unsigned short temp;
1259                GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
1260                temp+=LocalBufr.Channels_Sequence[i].Scaled_Iasi_Radiance[j];
1261                specs[k].Radiance[i*100+j]=temp-5000.;
1262               }
1263           }
1264         else
1265           {
1266            for (long k=0;k<s3.Number_Subsets;++k)
1267                specs[k].Radiance[i*100+j]=LocalBufr.Channels_Sequence[i].Scaled_Iasi_Radiance[j]-5000.;
1268           }
1269        }
1270    }
1271
1272
1273 // Scale radiances...
1274 for (long i=0;i<10;++i)
1275    {
1276     for (long k=0;k<s3.Number_Subsets;++k)
1277        {
1278         if (LocalChannel[k*10+i].Start_Channel<=8700)
1279           {
1280            for (long j=LocalChannel[k*10+i].Start_Channel-1;j<LocalChannel[k*10+i].End_Channel;++j)
1281               {
1282                specs[k].Radiance[j]*=pow(10.,-LocalChannel[k*10+i].Channel_Scale_Factor);
1283               }
1284           }
1285        }
1286    }
1287
1288 GetNextBits(s4.lpData,11,sizeof(LocalBufr.Satellite_Instruments_2),&LocalBufr.Satellite_Instruments_2,false); 
1289 GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
1290 if (NbBits>0)
1291   {
1292    for (long k=0;k<s3.Number_Subsets;++k)
1293       {
1294        unsigned short temp;
1295        GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
1296        temp+=LocalBufr.Satellite_Instruments_2;
1297       }
1298   }
1299 else
1300   {
1301   }
1302
1303 GetNextBits(s4.lpData, 7,sizeof(LocalBufr.AVHRR_channel_combination),&LocalBufr.AVHRR_channel_combination,false);
1304 // 1 bit per channel at most 6, 127 (0x7F) if absent.
1305 GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
1306 if (NbBits>0)
1307   {
1308    for (long k=0;k<s3.Number_Subsets;++k)
1309       {
1310        unsigned char temp;
1311        GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
1312        temp+=LocalBufr.AVHRR_channel_combination;
1313       }
1314   }
1315 else
1316   {
1317   }
1318
1319 //Reset AVHRR Scenes
1320 for (long k=0;k<s3.Number_Subsets;++k)
1321    {
1322     for (int i=0;i<6;++i) //  Pixels AVHRR
1323        {
1324         specs[k].Cloud_Free_Fraction[i]=-1.;
1325         for (int j=0;j<7;++j)
1326            {
1327             specs[k].AVHRR_Mean[i][j]=-1.;
1328             specs[k].AVHRR_Std[i][j]=-1.;
1329            }
1330        }
1331    }
1332
1333 /*
1334   Now we have 7 AVHRR Scenes
1335   Each of them contains
1336         - Y angular position        24 bits -8000000 *10^6  16777215    FFFFFF
1337         - Z angular position        24 bits -8000000 *10^6  16777215    FFFFFF
1338         - Fraction HIRS clear pixel  7 bits                      127        7F
1339         - 6 Channels
1340           with  - Channel Number     6 bits                       63        3F
1341                 - Scale Factor       6 bits                       63        3F
1342                 - Mean Radiance     31 bits               2147483647  7FFFFFFF
1343                 - Scale Factor       6 bits                       63        3F
1344                 - StDev Radiance    31 bits               2147483647  7FFFFFFF
1345 */ 
1346
1347 for (int i=0;i<7;++i) //  AVHRR Scenes
1348    {
1349     GetNextBits(s4.lpData,24,sizeof(LocalBufr.AVHRR_Scene_Sequence[i].Y_angular_position),&LocalBufr.AVHRR_Scene_Sequence[i].Y_angular_position,false); 
1350     GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
1351     if (NbBits>24)
1352       {
1353        return FALSE;
1354       }
1355     if (NbBits>0)
1356       {
1357        for (long k=0;k<s3.Number_Subsets;++k)
1358           {
1359            unsigned long temp;
1360            GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
1361            temp+=LocalBufr.AVHRR_Scene_Sequence[i].Y_angular_position;
1362           }
1363       }
1364     else
1365       {
1366       }
1367
1368     GetNextBits(s4.lpData,24,sizeof(LocalBufr.AVHRR_Scene_Sequence[i].Z_angular_position),&LocalBufr.AVHRR_Scene_Sequence[i].Z_angular_position,false); 
1369     GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
1370     if (NbBits>24)
1371       {
1372        return FALSE;
1373       }
1374     if (NbBits>0)
1375       {
1376        for (long k=0;k<s3.Number_Subsets;++k)
1377           {
1378            unsigned long temp;
1379            GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
1380            temp+=LocalBufr.AVHRR_Scene_Sequence[i].Z_angular_position;
1381           }
1382       }
1383     else
1384       {
1385       }
1386
1387     GetNextBits(s4.lpData, 7,sizeof(LocalBufr.AVHRR_Scene_Sequence[i].Fraction_clear_pixels_HIRS),&LocalBufr.AVHRR_Scene_Sequence[i].Fraction_clear_pixels_HIRS,false); 
1388     GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
1389     if (NbBits>7)
1390       {
1391        return FALSE;
1392       }
1393     if (NbBits>0)
1394       {
1395        for (long k=0;k<s3.Number_Subsets;++k)
1396           {
1397            unsigned char temp;
1398            GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
1399            temp+=LocalBufr.AVHRR_Scene_Sequence[i].Fraction_clear_pixels_HIRS;
1400            specs[k].Cloud_Free_Fraction [i]=(double)temp;
1401           }
1402       }
1403     else
1404       {
1405        for (long k=0;k<s3.Number_Subsets;++k)
1406           {
1407            specs[k].Cloud_Free_Fraction[i]=(double)LocalBufr.AVHRR_Scene_Sequence[i].Fraction_clear_pixels_HIRS;
1408           }
1409       }
1410
1411     for (int j=0;j<6;++j) // Channels
1412        {
1413         GetNextBits(s4.lpData, 6,sizeof(LocalBufr.AVHRR_Scene_Sequence[i].Channel_Number[j]),&LocalBufr.AVHRR_Scene_Sequence[i].Channel_Number[j],false); 
1414         GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
1415         if (NbBits>6)
1416           {
1417            return FALSE;
1418           }
1419         if (NbBits>0)
1420           {
1421            for (long k=0;k<s3.Number_Subsets;++k)
1422               {
1423                unsigned char temp;
1424                GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
1425                temp+=LocalBufr.AVHRR_Scene_Sequence[i].Channel_Number[j];
1426           }
1427           }
1428         else
1429           {
1430           }
1431
1432         GetNextBits(s4.lpData, 6,sizeof(LocalBufr.AVHRR_Scene_Sequence[i].Channel_Scale_Factor_1[j]),&LocalBufr.AVHRR_Scene_Sequence[i].Channel_Scale_Factor_1[j],false); 
1433         GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
1434         if (NbBits>6)
1435           {
1436            return FALSE;
1437           }
1438         if (NbBits>0)
1439           {
1440            for (long k=0;k<s3.Number_Subsets;++k)
1441               {
1442                unsigned char temp;
1443                GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
1444                temp+=LocalBufr.AVHRR_Scene_Sequence[i].Channel_Scale_Factor_1[j];
1445                specs[k].AVHRR_Mean[j][i]=pow(10.,-temp);
1446               }
1447           }
1448         else
1449           {
1450            for (long k=0;k<s3.Number_Subsets;++k)
1451               {
1452                specs[k].AVHRR_Mean[j][i]=pow(10.,-LocalBufr.AVHRR_Scene_Sequence[i].Channel_Scale_Factor_1[j]);
1453               }
1454           }
1455
1456         GetNextBits(s4.lpData,31,sizeof(LocalBufr.AVHRR_Scene_Sequence[i].Scaled_Mean_AVHRR_Rad[j]),&LocalBufr.AVHRR_Scene_Sequence[i].Scaled_Mean_AVHRR_Rad[j],false); 
1457         GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
1458         if (NbBits>31)
1459           {
1460            return FALSE;
1461           }
1462         if (NbBits>0)
1463           {
1464            for (long k=0;k<s3.Number_Subsets;++k)
1465               {
1466                unsigned long temp;               
1467                GetNextBits(s4.lpData,NbBits,4,&temp,false);
1468                temp+=LocalBufr.AVHRR_Scene_Sequence[i].Scaled_Mean_AVHRR_Rad[j];
1469                specs[k].AVHRR_Mean[j][i]=specs[k].AVHRR_Mean[j][i]*(double)temp;
1470               }
1471           }
1472         else
1473           {
1474            for (long k=0;k<s3.Number_Subsets;++k)
1475               {
1476                specs[k].AVHRR_Mean[j][i]*=LocalBufr.AVHRR_Scene_Sequence[i].Scaled_Mean_AVHRR_Rad[j];
1477               }
1478           }
1479
1480         GetNextBits(s4.lpData, 6,sizeof(LocalBufr.AVHRR_Scene_Sequence[i].Channel_Scale_Factor_2[j]),&LocalBufr.AVHRR_Scene_Sequence[i].Channel_Scale_Factor_2[j],false); 
1481         GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
1482         if (NbBits>6)
1483           {
1484            return FALSE;
1485           }
1486         if (NbBits>0)
1487           {
1488            for (long k=0;k<s3.Number_Subsets;++k)
1489               {
1490                unsigned char temp;
1491                GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
1492                temp+=LocalBufr.AVHRR_Scene_Sequence[i].Channel_Scale_Factor_2[j];
1493                specs[k].AVHRR_Std[j][i]=pow(10.,-temp);
1494               }
1495           }
1496         else
1497           {
1498            for (long k=0;k<s3.Number_Subsets;++k)
1499                specs[k].AVHRR_Std[j][i]=pow(10.,-LocalBufr.AVHRR_Scene_Sequence[i].Channel_Scale_Factor_2[j]);
1500           }
1501
1502         GetNextBits(s4.lpData,31,sizeof(LocalBufr.AVHRR_Scene_Sequence[i].Scaled_Std_AVHRR_Rad[j]),&LocalBufr.AVHRR_Scene_Sequence[i].Scaled_Std_AVHRR_Rad[j],false); 
1503         GetNextBits(s4.lpData,6,sizeof(NbBits),&NbBits,false);
1504         if (NbBits>31)
1505           {
1506            return FALSE;
1507           }
1508         if (NbBits>0)
1509           {
1510            for (long k=0;k<s3.Number_Subsets;++k)
1511               {
1512                unsigned long temp;
1513                GetNextBits(s4.lpData,NbBits,sizeof(temp),&temp,false);
1514                temp+=LocalBufr.AVHRR_Scene_Sequence[i].Scaled_Std_AVHRR_Rad[j];
1515                specs[k].AVHRR_Std[j][i]*=temp;
1516               }
1517           }
1518         else
1519           {
1520            for (long k=0;k<s3.Number_Subsets;++k)
1521                specs[k].AVHRR_Std[j][i]*=LocalBufr.AVHRR_Scene_Sequence[i].Scaled_Std_AVHRR_Rad[j];
1522           }
1523
1524        }
1525    }
1526 return TRUE;
1527}
Note: See TracBrowser for help on using the repository browser.