'당근이의 AVR 갖구 놀기'(이하 당근이)는 AVR을 한 번 만져본 사람이라면 누구나 한번씩은 방문해봤을 만큼 유명한 네이버 카페 중 하나이다.

처음에는 AVR에 관한 질의가 있어서 찾게 되었고, 많은 부분에 대한 문제해결을 본 게 계기가 되어 내게는 네이버에서 가장 즐겨찾는 카페중 하나가 되었다.
그리고, 현재는 엄마 몰래 리눅스 포팅이라는 강좌를 알게 되어서 자주 들락날락 거리고 있는 중이다.

학부 4학년때 처음으로 임베디드 리눅스에 대한 수업을 듣고 임베디드에 대해 관심을 가지게 되었다. 하지만 그 이후에는 고가의 관련장비도 문제거니와, 다른 프로젝트에 심혈을 기울이고 있는터라, 한동안 잊게 되었다.

그렇게 시간은 흘렀고, 현재 백수로 있는 동안 프로그래밍에 대한 감도 떨어지는 것 같아서 엄마 몰래 리눅스 포팅이라는 강좌를 계기로 다시금 관심분야에 대한 눈을 돌리고자 한다.

Framework에 대한 정의를 내려 보려고 하니..참 막막하기는 하다...

Framework, Architecture 등 너무도 익숙하게 사용하는 용어라 정의하기가 더욱 어려운 것 같다.

google에서 Framework에 대한 정의를 찾아보면 20 여개 정도가 검색이 되는데 그중 아래의 정의가 일반적으로 우리가 생각하는 Framework이 아닐까 생각한다.

In software development, a Framework is a defined support structure in which another software project can be organized and developed. Typically, a framework may include support programs, code libraries and a scripting language amongst other software to help develop and glue together the different components of your project.

소프트웨어 프로젝트에서 활용할 수 있는 기반 구조로 일반적으로 지원 프로그램, 코드 라이브러리 등 프로젝트의 다양한 컴포넌트들을 개발하고 유기적으로 결합하기 위해 사용하는 소프트웨어를 말한다.

과거에 공통 코드라는 명칭으로 사용하던 것들을 좀더 구조화 시켜 Framework이라 부른다고 생각하면 될 것 같다.

이 Framework도 Component Framework, Application Framework, Web Framework 등 분류 기준에 따라 다양하게 분류가 된다.

여기서는 두가지로만 분류하겠다.

1. Component Framework (또는 Vendor Framework) : .NET Framework, J2EE Framework 과 같은 기능 중심의 Framework

2. Application Framework : Component Framework 기반으로 Application 내의 요소(Component)들간의 유기적인 연관 관계를 고려한 Framework (대표적인 것이 Apache Struts Framework, 다양한 SI회사에서 사용하는 Framework [필자의 회사에도 SummaFramework이라는 이름으로 가지고 있다] 등)

이러한 Framework을 활용하는 이유는 당연히 프로젝트의 생산성 향상 및 프로젝트의 표준화 지원을 통해 Quality 향상 등이 이유가 될 것이다. (사실 Framework이라는 표현을 쓰지 않을때에도 공통 코드 형태로 프로젝트 마다 사용해 왔던 것이다..)

이러한 Framework과 Architecture, Component, Library을 비교해 보면

Architecture는 시스템을 구성하고 있는 구성요소들 및 관계의 구조를 표현한 것으로 Framework 보다 좀더 추상적인 개념으로 보면 되겠다.

Component는 특정 기능을 수행하기 위해 잘 정의된 인터페이스를 통해 독립적으로 개발된 소프트웨어 단위로 Framework 기반에서 동작하는 모듈로 생각하면 되겠다.

Library는 재사용 가능한 함수와 루틴들을 모아 놓은 것으로 이러한 Library를 구조화 시켜 Framework을 만든다고 보면 되겠다.

재사용의 범위는 일반적으로

Library < Component < Framework < Architecture

라고 볼 수 있겠다.

Well, here it is the decoder source.
It takes as an input a JPG file and decodes it into a truecolor BMP.

Opposite to the encoder, it's not so optimized or clear as I wanted.
But since I received a lot of emails asking for it, here it is.

It is written long ago and since then I was quite busy learning other stuff
and I haven't modified it as it should [Huffman decoder probably can be made
better and IDCT (the most consuming CPU part) -- should be done faster],
so don't expect a super fast decoder [though it's speed seems reasonable].
Few comments are in romanian.
Some ideas have been taken from Independent JPEG Group's JPEG software.
(IDCT routine is taken with minor modifications)

It compiles under WATCOM C (still my favourite compiler) 10.0 for DOS, and
VISUAL C 5.0 (if you turn on optimizations in VC 5.0, make sure that the option
"assume aliasing across function calls" it's turned on for the "jpegdec.c" module).
I haven't tested it under other compilers.

I don't know when I'll have the time to make it better, but in the meantime,
I'd like to hear from you if you make it more clear and/or faster.

You are free to modify it as you want, but it would be nice to say somewhere
that you used ideas from these routines.

Disclaimer
----------

NO WARRANTY PROVIDED WITH THIS PROGRAM.
So, use it at your own risk.
It's status: freeware.

Author email:
            cristic22@yahoo.com

////////////////////////////////////////////////

BEGINNING OF HEADERS

/////////////////////////////////////////////////

#ifndef __JPEGDEC_H__
#define __JPEGDEC_H__

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define BYTE unsigned char
#define WORD unsigned short int

#define DWORD unsigned int
#define SDWORD signed int

#define SBYTE signed char
#define SWORD signed short int

int load_JPEG_header(FILE *fp, DWORD *X_image, DWORD *Y_image);
void decode_JPEG_image();
int get_JPEG_buffer(WORD X_image,WORD Y_image, BYTE **address_dest_buffer);

#endif

/////////////////////////////////////////////////
BEGINNING OF PROGRAM SOURCE
//////////////////////////////////////////////////

#include "jpegdec.h"
#include <conio.h>
#include <time.h>
char *FileName="image.jpg";
extern char error_string[90];

typedef struct s_BM_header {
     WORD BMP_id ; // 'B''M'
     DWORD size; // size in bytes of the BMP file
     DWORD zero_res; // 0
     DWORD offbits; // 54
     DWORD biSize; // 0x28
     DWORD Width;  // X
     DWORD Height;  // Y
     WORD  biPlanes; // 1
     WORD  biBitCount ; // 24
     DWORD biCompression; // 0 = BI_RGB
     DWORD biSizeImage; // 0
     DWORD biXPelsPerMeter; // 0xB40
     DWORD biYPelsPerMeter; // 0xB40
     DWORD biClrUsed; //0
     DWORD biClrImportant; //0
} BM_header;
typedef struct s_RGB {
    BYTE B;
       BYTE G;
       BYTE R;
} RGB;

void exitmessage(char *message)
{
 printf("%s\n",message);exit(0);
}

void write_buf_to_BMP(BYTE *im_buffer, WORD X_bitmap, WORD Y_bitmap, char *BMPname)
{
 SWORD x,y;
 RGB *pixel;
 BM_header BH;
 FILE *fp_bitmap;
 DWORD im_loc_bytes;
 BYTE nr_fillingbytes, i;
 BYTE zero_byte=0;

 fp_bitmap=fopen(BMPname,"wb");
 if (fp_bitmap==NULL) exitmessage("File cannot be created");

 if (X_bitmap%4!=0) nr_fillingbytes=4-((X_bitmap*3L)%4);
  else nr_fillingbytes=0;

 BH.BMP_id = 'M'*256+'B';     fwrite(&BH.BMP_id,2,1,fp_bitmap);
 BH.size=54+Y_bitmap*(X_bitmap*3+nr_fillingbytes);fwrite(&BH.size,4,1,fp_bitmap);
 BH.zero_res = 0;             fwrite(&BH.zero_res,4,1,fp_bitmap);
 BH.offbits = 54;             fwrite(&BH.offbits,4,1,fp_bitmap);
 BH.biSize = 0x28;            fwrite(&BH.biSize,4,1,fp_bitmap);
 BH.Width = X_bitmap;       fwrite(&BH.Width,4,1,fp_bitmap);
 BH.Height = Y_bitmap;       fwrite(&BH.Height,4,1,fp_bitmap);
 BH.biPlanes = 1;             fwrite(&BH.biPlanes,2,1,fp_bitmap);
 BH.biBitCount = 24;          fwrite(&BH.biBitCount,2,1,fp_bitmap);
 BH.biCompression = 0;        fwrite(&BH.biCompression,4,1,fp_bitmap);
 BH.biSizeImage = 0;          fwrite(&BH.biSizeImage,4,1,fp_bitmap);
 BH.biXPelsPerMeter = 0xB40;  fwrite(&BH.biXPelsPerMeter,4,1,fp_bitmap);
 BH.biYPelsPerMeter = 0xB40;  fwrite(&BH.biYPelsPerMeter,4,1,fp_bitmap);
 BH.biClrUsed = 0;           fwrite(&BH.biClrUsed,4,1,fp_bitmap);
 BH.biClrImportant = 0;       fwrite(&BH.biClrImportant,4,1,fp_bitmap);

 printf("Writing bitmap ...\n");
 im_loc_bytes=(DWORD)im_buffer+((DWORD)Y_bitmap-1)*X_bitmap*4;

 for (y=0;y<Y_bitmap;y++)
  {
   for (x=0;x<X_bitmap;x++)
 {
  pixel=(RGB *)im_loc_bytes;
  fwrite(pixel, 3, 1, fp_bitmap);
  im_loc_bytes+=4;
 }
   for (i=0;i<nr_fillingbytes;i++)
    fwrite(&zero_byte,1,1,fp_bitmap);
   im_loc_bytes-=2L*X_bitmap*4;
  }
 printf("Done.\n");
 fclose(fp_bitmap);
}

void main(int argc, char *argv[])
{
 FILE *fp;
 DWORD X_image, Y_image;
 BYTE *our_image_buffer;
 clock_t start_time, finish_time;
 float duration;

 if (argc<=1) fp=fopen(FileName,"rb");
  else fp=fopen(argv[1],"rb");
 if (fp==NULL) exitmessage("File not found ?");
 if (!load_JPEG_header(fp,&X_image,&Y_image)) {exitmessage(error_string);return;}
 fclose(fp);

 printf(" X_image = %d\n",X_image);
 printf(" Y_image = %d\n",Y_image);

/*
 printf("Sampling factors: \n");
 printf("Y  : H=%d,V=%d\n", YH,YV);
 printf("Cb : H=%d,V=%d\n", CbH,CbV);
 printf("Cr : H=%d,V=%d\n", CrH,CrV);
 printf("Restart markers  = %d\n", Restart_markers);
 printf("MCU restart = %d\n", MCU_restart);
 getch();
*/

 printf("Decoding JPEG image...\n");
 // main decoder
 start_time = clock();
 decode_JPEG_image();
 printf("Decoding finished.\n");
 
 finish_time = clock();
 duration = (double)(finish_time - start_time) / CLK_TCK;
 printf( "Time elapsed: %2.1f seconds\n", duration );

 if (!get_JPEG_buffer(X_image,Y_image,&our_image_buffer)) {exitmessage(error_string);return;}

 write_buf_to_BMP(our_image_buffer,X_image,Y_image, "image.bmp");
 getch();
}

////////////////////////////////////////////////
DECODER SOURCE CODE
////////////////////////////////////////////////

// JPEG decoder module
// Copyright 1999 Cristi Cuturicu

#include "jpegdec.h"
// Used markers:
#define SOI 0xD8
#define EOI 0xD9
#define APP0 0xE0
#define SOF 0xC0
#define DQT 0xDB
#define DHT 0xC4
#define SOS 0xDA
#define DRI 0xDD
#define COM 0xFE

char error_string[90];
#define exit_func(err) { strcpy(error_string, err); return 0;}

static BYTE *buf; // the buffer we use for storing the entire JPG file

static BYTE bp; //current byte
static WORD wp; //current word

static DWORD byte_pos; // current byte position
#define BYTE_p(i) bp=buf[(i)++]
#define WORD_p(i) wp=(((WORD)(buf[(i)]))<<8) + buf[(i)+1]; (i)+=2

// WORD X_image_size,Y_image_size; // X,Y sizes of the image
static WORD X_round,Y_round; // The dimensions rounded to multiple of Hmax*8 (X_round)
     // and Ymax*8 (Y_round)

static BYTE *im_buffer; // RGBA image buffer
static DWORD X_image_bytes; // size in bytes of 1 line of the image = X_round * 4
static DWORD y_inc_value ; // 32*X_round; // used by decode_MCU_1x2,2x1,2x2

BYTE YH,YV,CbH,CbV,CrH,CrV; // sampling factors (horizontal and vertical) for Y,Cb,Cr
static WORD Hmax,Vmax;

static BYTE zigzag[64]={ 0, 1, 5, 6,14,15,27,28,
      2, 4, 7,13,16,26,29,42,
      3, 8,12,17,25,30,41,43,
      9,11,18,24,31,40,44,53,
     10,19,23,32,39,45,52,54,
     20,22,33,38,46,51,55,60,
     21,34,37,47,50,56,59,61,
     35,36,48,49,57,58,62,63 };
typedef struct {
   BYTE Length[17];  // k =1-16 ; L[k] indicates the number of Huffman codes of length k
   WORD minor_code[17];  // indicates the value of the smallest Huffman code of length k
   WORD major_code[17];  // similar, but the highest code
   BYTE V[65536];  // V[k][j] = Value associated to the j-th Huffman code of length k
 // High nibble = nr of previous 0 coefficients
 // Low nibble = size (in bits) of the coefficient which will be taken from the data stream
} Huffman_table;

static float *QT[4]; // quantization tables, no more than 4 quantization tables (QT[0..3])
static Huffman_table HTDC[4]; //DC huffman tables , no more than 4 (0..3)
static Huffman_table HTAC[4]; //AC huffman tables                  (0..3)

static BYTE YQ_nr,CbQ_nr,CrQ_nr; // quantization table number for Y, Cb, Cr
static BYTE YDC_nr,CbDC_nr,CrDC_nr; // DC Huffman table number for Y,Cb, Cr
static BYTE YAC_nr,CbAC_nr,CrAC_nr; // AC Huffman table number for Y,Cb, Cr

static BYTE Restart_markers; // if 1 => Restart markers on , 0 => no restart markers
static WORD MCU_restart; //Restart markers appears every MCU_restart MCU blocks
typedef void (*decode_MCU_func)(DWORD);

static SWORD DCY, DCCb, DCCr; // Coeficientii DC pentru Y,Cb,Cr
static SWORD DCT_coeff[64]; // Current DCT_coefficients
static BYTE Y[64],Cb[64],Cr[64]; // Y, Cb, Cr of the current 8x8 block for the 1x1 case
static BYTE Y_1[64],Y_2[64],Y_3[64],Y_4[64];
static BYTE tab_1[64],tab_2[64],tab_3[64],tab_4[64]; // tabelele de supraesantionare pt cele 4 blocuri

static SWORD Cr_tab[256],Cb_tab[256]; // Precalculated Cr, Cb tables
static SWORD Cr_Cb_green_tab[65536];

// Initial conditions:
// byte_pos = start position in the Huffman coded segment
// WORD_get(w1); WORD_get(w2);wordval=w1;

static BYTE d_k=0;  // Bit displacement in memory, relative to the offset of w1
    // it's always <16
static WORD w1,w2; // w1 = First word in memory; w2 = Second word
static DWORD wordval ; // the actual used value in Huffman decoding.
static DWORD mask[17];
static SWORD neg_pow2[17]={0,-1,-3,-7,-15,-31,-63,-127,-255,-511,-1023,-2047,-4095,-8191,-16383,-32767};
static DWORD start_neg_pow2=(DWORD)neg_pow2;

static int shift_temp;
#define RIGHT_SHIFT(x,shft)  \
 ((shift_temp = (x)) < 0 ? \
  (shift_temp >> (shft)) | ((~(0L)) << (32-(shft))) : \
  (shift_temp >> (shft)))
#define DESCALE(x,n)  RIGHT_SHIFT((x) + (1L << ((n)-1)), n)
#define RANGE_MASK 1023L
static BYTE *rlimit_table;
void prepare_range_limit_table()
/* Allocate and fill in the sample_range_limit table */
{
  int j;
  rlimit_table = (BYTE *)malloc(5 * 256L + 128) ;
  /* First segment of "simple" table: limit[x] = 0 for x < 0 */
  memset((void *)rlimit_table,0,256);
  rlimit_table += 256; /* allow negative subscripts of simple table */
  /* Main part of "simple" table: limit[x] = x */
  for (j = 0; j < 256; j++) rlimit_table[j] = j;
  /* End of simple table, rest of first half of post-IDCT table */
  for (j = 256; j < 640; j++) rlimit_table[j] = 255;
  /* Second half of post-IDCT table */
  memset((void *)(rlimit_table + 640),0,384);
  for (j = 0; j < 128 ; j++) rlimit_table[j+1024] = j;
}

#ifdef _MSC_VER
WORD lookKbits(BYTE k)
{
 _asm {
  mov dl, k
  mov cl, 16
  sub cl, dl
  mov eax, [wordval]
  shr eax, cl
 }
}

WORD WORD_hi_lo(BYTE byte_high,BYTE byte_low)
{
 _asm {
    mov ah,byte_high
    mov al,byte_low
   }
}
SWORD get_svalue(BYTE k)
// k>0 always
// Takes k bits out of the BIT stream (wordval), and makes them a signed value
{
 _asm {
     xor ecx, ecx
     mov cl,k
     mov eax,[wordval]
     shl eax,cl
     shr eax, 16
     dec cl
     bt eax,ecx
     jc end_macro
 signed_value:inc cl
     mov ebx,[start_neg_pow2]
     add ax,word ptr [ebx+ecx*2]
   end_macro:
 }
}
#endif

#ifdef __WATCOMC__

WORD lookKbits(BYTE k);
#pragma aux lookKbits=\
       "mov eax,[wordval]"\
       "mov cl, 16"\
       "sub cl, dl"\
       "shr eax, cl"\
        parm [dl] \
        value [ax] \
        modify [eax cl];
WORD WORD_hi_lo(BYTE byte_high,BYTE BYTE_low);
#pragma aux WORD_hi_lo=\
      parm [ah] [al]\
      value [ax] \
      modify [ax];

SWORD get_svalue(BYTE k);
// k>0 always
// Takes k bits out of the BIT stream (wordval), and makes them a signed value
#pragma aux get_svalue=\
   "xor ecx, ecx"\
   "mov cl, al"\
   "mov eax,[wordval]"\
   "shl eax, cl"\
   "shr eax, 16"\
   "dec cl"\
   "bt eax,ecx"\
   "jc end_macro"\
   "signed_value:inc cl"\
   "mov ebx,[start_neg_pow2]"\
   "add ax,word ptr [ebx+ecx*2]"\
   "end_macro:"\
   parm [al]\
   modify [eax ebx ecx]\
   value [ax];
#endif

void skipKbits(BYTE k)
{
 BYTE b_high,b_low;
 d_k+=k;
 if (d_k>=16) { d_k-=16;
  w1=w2;
  // Get the next word in w2
  BYTE_p(byte_pos);
  if (bp!=0xFF) b_high=bp;
  else {
     if (buf[byte_pos]==0) byte_pos++; //skip 00
     else byte_pos--; // stop byte_pos pe restart marker
     b_high=0xFF;
  }
  BYTE_p(byte_pos);
  if (bp!=0xFF) b_low=bp;
  else {
     if (buf[byte_pos]==0) byte_pos++; //skip 00
     else byte_pos--; // stop byte_pos pe restart marker
     b_low=0xFF;
  }
  w2=WORD_hi_lo(b_high,b_low);
 }

 wordval = ((DWORD)(w1)<<16) + w2;
 wordval <<= d_k;
 wordval >>= 16;
}

SWORD getKbits(BYTE k)
{
 SWORD signed_wordvalue;
 signed_wordvalue=get_svalue(k);
 skipKbits(k);
 return signed_wordvalue;
}

void calculate_mask()
{
  BYTE k;
  DWORD tmpdv;
  for (k=0;k<=16;k++) { tmpdv=0x10000;mask[k]=(tmpdv>>k)-1;} //precalculated bit mask
}

void init_QT()
{
 BYTE i;
 for (i=0;i<=3;i++) QT[i]=(float *)malloc(sizeof(float)*64);
}

void load_quant_table(float *quant_table)
{
 float scalefactor[8]={1.0f, 1.387039845f, 1.306562965f, 1.175875602f,
        1.0f, 0.785694958f, 0.541196100f, 0.275899379f};
 BYTE j,row,col;
// Load quantization coefficients from JPG file, scale them for DCT and reorder
// from zig-zag order
 for (j=0;j<=63;j++) quant_table[j]=buf[byte_pos+zigzag[j]];
 j=0;
 for (row=0;row<=7;row++)
   for (col=0;col<=7;col++) {
  quant_table[j]*=scalefactor[row]*scalefactor[col];
  j++;
   }
 byte_pos+=64;
}

void load_Huffman_table(Huffman_table *HT)
{
  BYTE k,j;
  DWORD code;

  for (j=1;j<=16;j++) {
 BYTE_p(byte_pos);
 HT->Length[j]=bp;
  }
  for (k=1;k<=16;k++)
 for (j=0;j<HT->Length[k];j++) {
  BYTE_p(byte_pos);
  HT->V[WORD_hi_lo(k,j)]=bp;
 }

  code=0;
  for (k=1;k<=16;k++) {
  HT->minor_code[k] = (WORD)code;
  for (j=1;j<=HT->Length[k];j++) code++;
  HT->major_code[k]=(WORD)(code-1);
  code*=2;
  if (HT->Length[k]==0) {
  HT->minor_code[k]=0xFFFF;
  HT->major_code[k]=0;
  }
  }
}

void process_Huffman_data_unit(BYTE DC_nr, BYTE AC_nr,SWORD *previous_DC)
{
// Process one data unit. A data unit = 64 DCT coefficients
// Data is decompressed by Huffman decoding, then the array is dezigzag-ed
// The result is a 64 DCT coefficients array: DCT_coeff
   BYTE nr,k,j,EOB_found;
   register WORD tmp_Hcode;
   BYTE size_val,count_0;
   WORD *min_code,*maj_code; // min_code[k]=minimum code of length k, maj_code[k]=similar but maximum
   WORD *max_val, *min_val;
   BYTE *huff_values;
   SWORD DCT_tcoeff[64];
   BYTE byte_temp;

// Start Huffman decoding
// First the DC coefficient decoding
   min_code=HTDC[DC_nr].minor_code;
   maj_code=HTDC[DC_nr].major_code;
   huff_values=HTDC[DC_nr].V;

   for (nr = 0; nr < 64 ; nr++) DCT_tcoeff[nr] = 0; //Initialize DCT_tcoeff

   nr=0;// DC coefficient

   min_val = &min_code[1]; max_val = &maj_code[1];
   for (k=1;k<=16;k++) {
  tmp_Hcode=lookKbits(k);
//    max_val = &maj_code[k]; min_val = &min_code[k];
  if ( (tmp_Hcode<=*max_val)&&(tmp_Hcode>=*min_val) ) { //Found a valid Huffman code
  skipKbits(k);
  size_val=huff_values[WORD_hi_lo(k,(BYTE)(tmp_Hcode-*min_val))];
  if (size_val==0) DCT_tcoeff[0]=*previous_DC;
  else {
   DCT_tcoeff[0]=*previous_DC+getKbits(size_val);
   *previous_DC=DCT_tcoeff[0];
  }
  break;
  }
  min_val++; max_val++;
   }

// Second, AC coefficient decoding
   min_code=HTAC[AC_nr].minor_code;
   maj_code=HTAC[AC_nr].major_code;
   huff_values=HTAC[AC_nr].V;

   nr=1; // AC coefficient
   EOB_found=0;
   while ( (nr<=63)&&(!EOB_found) )
 {
  max_val = &maj_code[1]; min_val =&min_code[1];
  for (k=1;k<=16;k++)
  {
    tmp_Hcode=lookKbits(k);
//    max_val = &maj_code[k]; &min_val = min_code[k];
    if ( (tmp_Hcode<=*max_val)&&(tmp_Hcode>=*min_val) )
    {
  skipKbits(k);
  byte_temp=huff_values[WORD_hi_lo(k,(BYTE)(tmp_Hcode-*min_val))];
  size_val=byte_temp&0xF;
  count_0=byte_temp>>4;
  if (size_val==0) {if (count_0==0) EOB_found=1;
        else if (count_0==0xF) nr+=16; //skip 16 zeroes
      }
  else
  {
   nr+=count_0; //skip count_0 zeroes
   DCT_tcoeff[nr++]=getKbits(size_val);
  }
  break;
    }
    min_val++; max_val++;
  }
  if (k>16) nr++;  // This should not occur
 }
  for (j=0;j<=63;j++) DCT_coeff[j]=DCT_tcoeff[zigzag[j]]; // Et, voila ... DCT_coeff
}

void IDCT_transform(SWORD *incoeff,BYTE *outcoeff,BYTE Q_nr)
// Fast float IDCT transform
{
 BYTE x;
 SBYTE y;
 SWORD *inptr;
 BYTE *outptr;
 float workspace[64];
 float *wsptr;//Workspace pointer
 float *quantptr; // Quantization table pointer
 float dcval;
 float tmp0,tmp1,tmp2,tmp3,tmp4,tmp5,tmp6,tmp7;
 float tmp10,tmp11,tmp12,tmp13;
 float z5,z10,z11,z12,z13;
 BYTE *range_limit=rlimit_table+128;
 // Pass 1: process COLUMNS from input and store into work array.
 wsptr=workspace;
 inptr=incoeff;
 quantptr=QT[Q_nr];
 for (y=0;y<=7;y++)
  {
   if( (inptr[8]|inptr[16]|inptr[24]|inptr[32]|inptr[40]|inptr[48]|inptr[56])==0)
 {
  // AC terms all zero (in a column)
  dcval=inptr[0]*quantptr[0];
  wsptr[0]  = dcval;
  wsptr[8]  = dcval;
  wsptr[16] = dcval;
  wsptr[24] = dcval;
  wsptr[32] = dcval;
  wsptr[40] = dcval;
  wsptr[48] = dcval;
  wsptr[56] = dcval;
  inptr++;quantptr++;wsptr++;//advance pointers to next column
  continue ;
 }
  //Even part
 tmp0 = inptr[0] *quantptr[0];
 tmp1 = inptr[16]*quantptr[16];
 tmp2 = inptr[32]*quantptr[32];
 tmp3 = inptr[48]*quantptr[48];

 tmp10 = tmp0 + tmp2;// phase 3
 tmp11 = tmp0 - tmp2;

 tmp13 = tmp1 + tmp3;// phases 5-3
 tmp12 = (tmp1 - tmp3) * 1.414213562f - tmp13; // 2*c4

 tmp0 = tmp10 + tmp13;// phase 2
 tmp3 = tmp10 - tmp13;
 tmp1 = tmp11 + tmp12;
 tmp2 = tmp11 - tmp12;

 // Odd part
 tmp4 = inptr[8] *quantptr[8];
 tmp5 = inptr[24]*quantptr[24];
 tmp6 = inptr[40]*quantptr[40];
 tmp7 = inptr[56]*quantptr[56];

 z13 = tmp6 + tmp5;// phase 6
 z10 = tmp6 - tmp5;
 z11 = tmp4 + tmp7;
 z12 = tmp4 - tmp7;

 tmp7 = z11 + z13;// phase 5
 tmp11= (z11 - z13) * 1.414213562f; // 2*c4

 z5 = (z10 + z12) * 1.847759065f; // 2*c2
 tmp10 = 1.082392200f * z12 - z5; // 2*(c2-c6)
 tmp12 = -2.613125930f * z10 + z5;// -2*(c2+c6)

 tmp6 = tmp12 - tmp7;// phase 2
 tmp5 = tmp11 - tmp6;
 tmp4 = tmp10 + tmp5;

 wsptr[0]  = tmp0 + tmp7;
 wsptr[56] = tmp0 - tmp7;
 wsptr[8]  = tmp1 + tmp6;
 wsptr[48] = tmp1 - tmp6;
 wsptr[16] = tmp2 + tmp5;
 wsptr[40] = tmp2 - tmp5;
 wsptr[32] = tmp3 + tmp4;
 wsptr[24] = tmp3 - tmp4;
 inptr++;
 quantptr++;
 wsptr++;//advance pointers to the next column
  }

//  Pass 2: process ROWS from work array, store into output array.
// Note that we must descale the results by a factor of 8 = 2^3
 outptr=outcoeff;
 wsptr=workspace;
 for (x=0;x<=7;x++)
  {
   // Even part
 tmp10 = wsptr[0] + wsptr[4];
 tmp11 = wsptr[0] - wsptr[4];

 tmp13 = wsptr[2] + wsptr[6];
 tmp12 =(wsptr[2] - wsptr[6]) * 1.414213562f - tmp13;

 tmp0 = tmp10 + tmp13;
 tmp3 = tmp10 - tmp13;
 tmp1 = tmp11 + tmp12;
 tmp2 = tmp11 - tmp12;

   // Odd part
 z13 = wsptr[5] + wsptr[3];
 z10 = wsptr[5] - wsptr[3];
 z11 = wsptr[1] + wsptr[7];
 z12 = wsptr[1] - wsptr[7];

 tmp7 = z11 + z13;
 tmp11= (z11 - z13) * 1.414213562f;

 z5 = (z10 + z12) * 1.847759065f; // 2*c2
 tmp10 = 1.082392200f * z12 - z5;  // 2*(c2-c6)
 tmp12 = -2.613125930f * z10 + z5; // -2*(c2+c6)

 tmp6 = tmp12 - tmp7;
 tmp5 = tmp11 - tmp6;
 tmp4 = tmp10 + tmp5;

 // Final output stage: scale down by a factor of 8
 outptr[0] = range_limit[(DESCALE((int) (tmp0 + tmp7), 3)) & 1023L];
 outptr[7] = range_limit[(DESCALE((int) (tmp0 - tmp7), 3)) & 1023L];
 outptr[1] = range_limit[(DESCALE((int) (tmp1 + tmp6), 3)) & 1023L];
 outptr[6] = range_limit[(DESCALE((int) (tmp1 - tmp6), 3)) & 1023L];
 outptr[2] = range_limit[(DESCALE((int) (tmp2 + tmp5), 3)) & 1023L];
 outptr[5] = range_limit[(DESCALE((int) (tmp2 - tmp5), 3)) & 1023L];
 outptr[4] = range_limit[(DESCALE((int) (tmp3 + tmp4), 3)) & 1023L];
 outptr[3] = range_limit[(DESCALE((int) (tmp3 - tmp4), 3)) & 1023L];

 wsptr+=8;//advance pointer to the next row
 outptr+=8;
  }
}

void precalculate_Cr_Cb_tables()
{
 WORD k;
 WORD Cr_v,Cb_v;
 for (k=0;k<=255;k++) Cr_tab[k]=(SWORD)((k-128.0)*1.402);
 for (k=0;k<=255;k++) Cb_tab[k]=(SWORD)((k-128.0)*1.772);

 for (Cr_v=0;Cr_v<=255;Cr_v++)
  for (Cb_v=0;Cb_v<=255;Cb_v++)
   Cr_Cb_green_tab[((WORD)(Cr_v)<<8)+Cb_v]=(int)(-0.34414*(Cb_v-128.0)-0.71414*(Cr_v-128.0));

}

void convert_8x8_YCbCr_to_RGB(BYTE *Y, BYTE *Cb, BYTE *Cr, DWORD im_loc, DWORD X_image_bytes, BYTE *im_buffer)
// Functia (ca optimizare) poate fi apelata si fara parametrii Y,Cb,Cr
// Stim ca va fi apelata doar in cazul 1x1
{
  DWORD x,y;
  BYTE im_nr;
  BYTE *Y_val = Y, *Cb_val = Cb, *Cr_val = Cr;
  BYTE *ibuffer = im_buffer + im_loc;

  for (y=0;y<8;y++)
   {
 im_nr=0;
 for (x=0;x<8;x++)
   {
    ibuffer[im_nr++] = rlimit_table[*Y_val + Cb_tab[*Cb_val]]; //B
    ibuffer[im_nr++] = rlimit_table[*Y_val + Cr_Cb_green_tab[WORD_hi_lo(*Cr_val,*Cb_val)]]; //G
    ibuffer[im_nr++] = rlimit_table[*Y_val + Cr_tab[*Cr_val]]; // R
/*
// Monochrome display
    im_buffer[im_nr++] = *Y_val;
    im_buffer[im_nr++] = *Y_val;
    im_buffer[im_nr++] = *Y_val;
*/
    Y_val++; Cb_val++; Cr_val++; im_nr++;
   }
 ibuffer+=X_image_bytes;
   }
}

void convert_8x8_YCbCr_to_RGB_tab(BYTE *Y, BYTE *Cb, BYTE *Cr, BYTE *tab, DWORD im_loc, DWORD X_image_bytes, BYTE *im_buffer)
// Functia (ca optimizare) poate fi apelata si fara parametrii Cb,Cr
{
  DWORD x,y;
  BYTE nr, im_nr;
  BYTE Y_val,Cb_val,Cr_val;
  BYTE *ibuffer = im_buffer + im_loc;

  nr=0;
  for (y=0;y<8;y++)
   {
 im_nr=0;
 for (x=0;x<8;x++)
   {
    Y_val=Y[nr];
    Cb_val=Cb[tab[nr]]; Cr_val=Cr[tab[nr]]; // reindexare folosind tabelul
    // de supraesantionare precalculat
    ibuffer[im_nr++] = rlimit_table[Y_val + Cb_tab[Cb_val]]; //B
    ibuffer[im_nr++] = rlimit_table[Y_val + Cr_Cb_green_tab[WORD_hi_lo(Cr_val,Cb_val)]]; //G
    ibuffer[im_nr++] = rlimit_table[Y_val + Cr_tab[Cr_val]]; // R
    nr++; im_nr++;
   }
 ibuffer+=X_image_bytes;
   }
}

void calculate_tabs()
{
 BYTE tab_temp[256];
 BYTE x,y;

 // Tabelul de supraesantionare 16x16
 for (y=0;y<16;y++)
  for (x=0;x<16;x++)
    tab_temp[y*16+x] = (y/YV)* 8 + x/YH;

 // Din el derivam tabelele corespunzatoare celor 4 blocuri de 8x8 pixeli
 for (y=0;y<8;y++)
 {
  for (x=0;x<8;x++)
   tab_1[y*8+x]=tab_temp[y*16+x];
  for (x=8;x<16;x++)
   tab_2[y*8+(x-8)]=tab_temp[y*16+x];
 }
 for (y=8;y<16;y++)
 {
  for (x=0;x<8;x++)
   tab_3[(y-8)*8+x]=tab_temp[y*16+x];
  for (x=8;x<16;x++)
   tab_4[(y-8)*8+(x-8)]=tab_temp[y*16+x];
 }
}

int init_JPG_decoding()
{
 byte_pos=0;
 init_QT();
 calculate_mask();
 prepare_range_limit_table();
 precalculate_Cr_Cb_tables();
 return 1; //for future error check
}

DWORD filesize(FILE *fp)
{
 DWORD pos;
 DWORD pos_cur;
 pos_cur=ftell(fp);
 fseek(fp,0,SEEK_END);
 pos=ftell(fp);
 fseek(fp,pos_cur,SEEK_SET);
 return pos;
}

int load_JPEG_header(FILE *fp, DWORD *X_image, DWORD *Y_image)
{
 DWORD length_of_file;
 BYTE vers,units;
 WORD Xdensity,Ydensity,Xthumbnail,Ythumbnail;
 WORD length;
 float *qtable;
 DWORD old_byte_pos;
 Huffman_table *htable;
 DWORD j;
 BYTE precision,comp_id,nr_components;
 BYTE QT_info,HT_info;
 BYTE SOS_found,SOF_found;

 length_of_file=filesize(fp);
 buf=(BYTE *)malloc(length_of_file+4);
 if (buf==NULL) exit_func("Not enough memory for loading file");
 fread(buf,length_of_file,1,fp);

 if ((buf[0]!=0xFF)||(buf[1]!=SOI)) exit_func("Not a JPG file ?\n");
 if ((buf[2]!=0xFF)||(buf[3]!=APP0)) exit_func("Invalid JPG file.");
 if ( (buf[6]!='J')||(buf[7]!='F')||(buf[8]!='I')||(buf[9]!='F')||
   (buf[10]!=0) ) exit_func("Invalid JPG file.");

 init_JPG_decoding();
 byte_pos=11;

 BYTE_p(byte_pos);vers=bp;
 if (vers!=1) exit_func("JFIF version not supported");
 BYTE_p(byte_pos); // vers_lo=bp;
 BYTE_p(byte_pos);  units=bp;
 if (units!=0) //exit_func("JPG format not supported");
 ;// printf("units = %d\n", units);
 WORD_p(byte_pos); Xdensity=wp; WORD_p(byte_pos); Ydensity=wp;
 if ((Xdensity!=1)||(Ydensity!=1)) //exit_func("JPG format not supported");
  ;  //{printf("X density = %d\n",Xdensity); printf("Y density = %d\n",Ydensity);}
 BYTE_p(byte_pos);Xthumbnail=bp;BYTE_p(byte_pos);Ythumbnail=bp;
 if ((Xthumbnail!=0)||(Ythumbnail!=0))
 exit_func(" Cannot process JFIF thumbnailed files\n");
 // Start decoding process
 SOS_found=0; SOF_found=0; Restart_markers=0;
 while ((byte_pos<length_of_file)&&!SOS_found)
 {
  BYTE_p(byte_pos);
  if (bp!=0xFF) continue;
  // A marker was found
  BYTE_p(byte_pos);
  switch(bp)
  {
   case DQT: WORD_p(byte_pos); length=wp; // length of the DQT marker
    for (j=0;j<wp-2;)
    {
     old_byte_pos=byte_pos;
     BYTE_p(byte_pos); QT_info=bp;
     if ((QT_info>>4)!=0)
     exit_func("16 bit quantization table not supported");
     qtable=QT[QT_info&0xF];
     load_quant_table(qtable);
     j+=byte_pos-old_byte_pos;
    }
    break;
   case DHT: WORD_p(byte_pos); length=wp;
    for (j=0;j<wp-2;)
    {
     old_byte_pos=byte_pos;
     BYTE_p(byte_pos); HT_info=bp;
     if ((HT_info&0x10)!=0) htable=&HTAC[HT_info&0xF];
     else htable=&HTDC[HT_info&0xF];
     load_Huffman_table(htable);
     j+=byte_pos-old_byte_pos;
    }
    break;
   case COM: WORD_p(byte_pos); length=wp;
    byte_pos+=wp-2;
    break;
   case DRI: Restart_markers=1;
    WORD_p(byte_pos); length=wp; //should be = 4
    WORD_p(byte_pos);  MCU_restart=wp;
    if (MCU_restart==0) Restart_markers=0;
    break;
   case SOF: WORD_p(byte_pos); length=wp; //should be = 8+3*3=17
    BYTE_p(byte_pos); precision=bp;
    if (precision!=8) exit_func("Only 8 bit precision supported");
    WORD_p(byte_pos); *Y_image=wp; WORD_p(byte_pos); *X_image=wp;
    BYTE_p(byte_pos); nr_components=bp;
    if (nr_components!=3) exit_func("Only truecolor JPGS supported");
    for (j=1;j<=3;j++)
    {
     BYTE_p(byte_pos); comp_id=bp;
     if ((comp_id==0)||(comp_id>3)) exit_func("Only YCbCr format supported");
     switch (comp_id)
     {
      case 1: // Y
       BYTE_p(byte_pos); YH=bp>>4;YV=bp&0xF;
       BYTE_p(byte_pos); YQ_nr=bp;
       break;
      case 2: // Cb
       BYTE_p(byte_pos); CbH=bp>>4;CbV=bp&0xF;
       BYTE_p(byte_pos); CbQ_nr=bp;
       break;
      case 3: // Cr
       BYTE_p(byte_pos); CrH=bp>>4;CrV=bp&0xF;
       BYTE_p(byte_pos); CrQ_nr=bp;
       break;
     }
    }
    SOF_found=1;
    break;
   case SOS: WORD_p(byte_pos); length=wp; //should be = 6+3*2=12
   BYTE_p(byte_pos); nr_components=bp;
   if (nr_components!=3) exit_func("Invalid SOS marker");
   for (j=1;j<=3;j++)
     {
   BYTE_p(byte_pos); comp_id=bp;
   if ((comp_id==0)||(comp_id>3)) exit_func("Only YCbCr format supported");
   switch (comp_id)
   {
    case 1: // Y
     BYTE_p(byte_pos); YDC_nr=bp>>4;YAC_nr=bp&0xF;
     break;
    case 2: // Cb
     BYTE_p(byte_pos); CbDC_nr=bp>>4;CbAC_nr=bp&0xF;
     break;
    case 3: // Cr
     BYTE_p(byte_pos); CrDC_nr=bp>>4;CrAC_nr=bp&0xF;
     break;
   }
     }
   BYTE_p(byte_pos); BYTE_p(byte_pos); BYTE_p(byte_pos); // Skip 3 bytes
   SOS_found=1;
   break;
   case 0xFF:
   break; // do nothing for 0xFFFF, sequence of consecutive 0xFF are for
   // filling purposes and should be ignored
   default:  WORD_p(byte_pos); length=wp;
   byte_pos+=wp-2; //skip unknown marker
   break;
  }
 }
 if (!SOS_found) exit_func("Invalid JPG file. No SOS marker found.");
 if (!SOF_found) exit_func("Progressive JPEGs not supported");

 if ((CbH>YH)||(CrH>YH)) exit_func("Vertical sampling factor for Y should be >= sampling factor for Cb,Cr");
 if ((CbV>YV)||(CrV>YV)) exit_func("Horizontal sampling factor for Y should be >= sampling factor for Cb,Cr");

 if ((CbH>=2)||(CbV>=2)) exit_func("Cb sampling factors should be = 1");
 if ((CrV>=2)||(CrV>=2)) exit_func("Cr sampling factors should be = 1");

// Restricting sampling factors for Y,Cb,Cr should give us 4 possible cases for sampling factors
// YHxYV,CbHxCbV,CrHxCrV: 2x2,1x1,1x1;  1x2,1x1,1x1; 2x1,1x1,1x1;
// and 1x1,1x1,1x1 = no upsampling needed

 Hmax=YH,Vmax=YV;
 if ( *X_image%(Hmax*8)==0) X_round=*X_image; // X_round = Multiple of Hmax*8
 else X_round=(*X_image/(Hmax*8)+1)*(Hmax*8);
 if ( *Y_image%(Vmax*8)==0) Y_round=*Y_image; // Y_round = Multiple of Vmax*8
 else Y_round=(*Y_image/(Vmax*8)+1)*(Vmax*8);

 im_buffer=(BYTE *)malloc(X_round*Y_round*4);
 if (im_buffer==NULL) exit_func("Not enough memory for storing the JPEG image");

 return 1;
}

void resync()
// byte_pos  = pozitionat pe restart marker
{
 byte_pos+=2;
 BYTE_p(byte_pos);
 if (bp==0xFF) byte_pos++; // skip 00
 w1=WORD_hi_lo(bp, 0);
 BYTE_p(byte_pos);
 if (bp==0xFF) byte_pos++; // skip 00
 w1+=bp;
 BYTE_p(byte_pos);
 if (bp==0xFF) byte_pos++; // skip 00
 w2=WORD_hi_lo(bp, 0);
 BYTE_p(byte_pos);
 if (bp==0xFF) byte_pos++; // skip 00
 w2+=bp;
 wordval=w1; d_k=0; // Reinit bitstream decoding
 DCY=0; DCCb=0; DCCr=0; // Init DC coefficients
}

void decode_MCU_1x1(DWORD im_loc)
{
 // Y
 process_Huffman_data_unit(YDC_nr,YAC_nr,&DCY);
 IDCT_transform(DCT_coeff,Y,YQ_nr);
 // Cb
 process_Huffman_data_unit(CbDC_nr,CbAC_nr,&DCCb);
 IDCT_transform(DCT_coeff,Cb,CbQ_nr);
 // Cr
 process_Huffman_data_unit(CrDC_nr,CrAC_nr,&DCCr);
 IDCT_transform(DCT_coeff,Cr,CrQ_nr);

 convert_8x8_YCbCr_to_RGB(Y,Cb,Cr,im_loc,X_image_bytes,im_buffer);
}
void decode_MCU_2x1(DWORD im_loc)
{
 // Y
 process_Huffman_data_unit(YDC_nr,YAC_nr,&DCY);
 IDCT_transform(DCT_coeff,Y_1,YQ_nr);
 process_Huffman_data_unit(YDC_nr,YAC_nr,&DCY);
 IDCT_transform(DCT_coeff,Y_2,YQ_nr);
 // Cb
 process_Huffman_data_unit(CbDC_nr,CbAC_nr,&DCCb);
 IDCT_transform(DCT_coeff,Cb,CbQ_nr);
 // Cr
 process_Huffman_data_unit(CrDC_nr,CrAC_nr,&DCCr);
 IDCT_transform(DCT_coeff,Cr,CrQ_nr);

 convert_8x8_YCbCr_to_RGB_tab(Y_1,Cb,Cr,tab_1,im_loc,X_image_bytes,im_buffer);
 convert_8x8_YCbCr_to_RGB_tab(Y_2,Cb,Cr,tab_2,im_loc+32,X_image_bytes,im_buffer);
}

void decode_MCU_2x2(DWORD im_loc)
{
 // Y
 process_Huffman_data_unit(YDC_nr,YAC_nr,&DCY);
 IDCT_transform(DCT_coeff,Y_1,YQ_nr);
 process_Huffman_data_unit(YDC_nr,YAC_nr,&DCY);
 IDCT_transform(DCT_coeff,Y_2,YQ_nr);
 process_Huffman_data_unit(YDC_nr,YAC_nr,&DCY);
 IDCT_transform(DCT_coeff,Y_3,YQ_nr);
 process_Huffman_data_unit(YDC_nr,YAC_nr,&DCY);
 IDCT_transform(DCT_coeff,Y_4,YQ_nr);
 // Cb
 process_Huffman_data_unit(CbDC_nr,CbAC_nr,&DCCb);
 IDCT_transform(DCT_coeff,Cb,CbQ_nr);
 // Cr
 process_Huffman_data_unit(CrDC_nr,CrAC_nr,&DCCr);
 IDCT_transform(DCT_coeff,Cr,CrQ_nr);

 convert_8x8_YCbCr_to_RGB_tab(Y_1,Cb,Cr,tab_1,im_loc,X_image_bytes,im_buffer);
 convert_8x8_YCbCr_to_RGB_tab(Y_2,Cb,Cr,tab_2,im_loc+32,X_image_bytes,im_buffer);
 convert_8x8_YCbCr_to_RGB_tab(Y_3,Cb,Cr,tab_3,im_loc+y_inc_value,X_image_bytes,im_buffer);
 convert_8x8_YCbCr_to_RGB_tab(Y_4,Cb,Cr,tab_4,im_loc+y_inc_value+32,X_image_bytes,im_buffer);
}

void decode_MCU_1x2(DWORD im_loc)
{
 // Y
 process_Huffman_data_unit(YDC_nr,YAC_nr,&DCY);
 IDCT_transform(DCT_coeff,Y_1,YQ_nr);
 process_Huffman_data_unit(YDC_nr,YAC_nr,&DCY);
 IDCT_transform(DCT_coeff,Y_2,YQ_nr);
 // Cb
 process_Huffman_data_unit(CbDC_nr,CbAC_nr,&DCCb);
 IDCT_transform(DCT_coeff,Cb,CbQ_nr);
 // Cr
 process_Huffman_data_unit(CrDC_nr,CrAC_nr,&DCCr);
 IDCT_transform(DCT_coeff,Cr,CrQ_nr);

 convert_8x8_YCbCr_to_RGB_tab(Y_1,Cb,Cr,tab_1,im_loc,X_image_bytes,im_buffer);
 convert_8x8_YCbCr_to_RGB_tab(Y_2,Cb,Cr,tab_3,im_loc+y_inc_value,X_image_bytes,im_buffer);
}

void decode_JPEG_image()
{
 decode_MCU_func decode_MCU;

 WORD x_mcu_cnt,y_mcu_cnt;
 DWORD nr_mcu;
 WORD X_MCU_nr,Y_MCU_nr; // Nr de MCU-uri
 DWORD MCU_dim_x; //dimensiunea in bufferul imagine a unui MCU pe axa x
 DWORD im_loc_inc; // = 7 * X_round * 4 sau 15*X_round*4;
 DWORD im_loc; //locatia in bufferul imagine

 byte_pos-=2;
 resync();

 y_inc_value = 32*X_round;
 calculate_tabs(); // Calcul tabele de supraesantionare, tinand cont de YH si YV

 if ((YH==1)&&(YV==1)) decode_MCU=decode_MCU_1x1;
 else {
    if (YH==2)
    {
  if (YV==2) decode_MCU=decode_MCU_2x2;
  else decode_MCU=decode_MCU_2x1;
    }
    else decode_MCU=decode_MCU_1x2;
 }
 MCU_dim_x=Hmax*8*4;

 Y_MCU_nr=Y_round/(Vmax*8); // nr of MCUs on Y axis
 X_MCU_nr=X_round/(Hmax*8); // nr of MCUs on X axis

 X_image_bytes=X_round*4; im_loc_inc = (Vmax*8-1) * X_image_bytes;
 nr_mcu=0; im_loc=0; // memory location of the current MCU
 for (y_mcu_cnt=0;y_mcu_cnt<Y_MCU_nr;y_mcu_cnt++)
 {
  for (x_mcu_cnt=0;x_mcu_cnt<X_MCU_nr;x_mcu_cnt++)
   {
 decode_MCU(im_loc);
 if ((Restart_markers)&&((nr_mcu+1)%MCU_restart==0)) resync();
 nr_mcu++;
 im_loc+=MCU_dim_x;
   }
  im_loc+=im_loc_inc;
 }
}

int get_JPEG_buffer(WORD X_image,WORD Y_image, BYTE **address_dest_buffer)
{
 WORD y;
 DWORD dest_loc=0;
 BYTE *src_buffer=im_buffer;
 BYTE *dest_buffer_start, *dest_buffer;

 DWORD src_bytes_per_line=X_round*4;
 DWORD dest_bytes_per_line=X_image*4;

 if ((X_round==X_image)&&(Y_round==Y_image))
 *address_dest_buffer=im_buffer;
 else
 {
  dest_buffer_start = (BYTE *)malloc(X_image*Y_image*4);
  if (dest_buffer_start==NULL) exit_func("Not enough memory for storing the JPEG image");
  dest_buffer = dest_buffer_start;
  for (y=0;y<Y_image;y++) {
    memcpy(dest_buffer,src_buffer,dest_bytes_per_line);
    src_buffer+=src_bytes_per_line;
    dest_buffer+=dest_bytes_per_line;
  }
 *address_dest_buffer=dest_buffer_start;
 free(im_buffer);
 }
// release the buffer which contains the JPG file
 free(buf);
 return 1;
}

////////////////////////////////////////////////
END OF SOURCE CODE
//////////////////////////////////////////////

/*
 select.c
*/

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/timeb.h>

#define BUFSIZE 30

int main(int argc, char * argv)
{
 fd_set reads, temps;
 int result;

 char message[BUFSIZE];
 int str_len;
 struct timeval timeout;

 FD_ZERO(&reads);
 FD_SET(0, &reads);
/*
 timeout.tv_sec = 5;
 timeout.tv_usec = 100000;
*/
 while( true )
 {
  temps = reads;
  timeout.tv_sec = 5;
  timeout.tv_usec = 0;

  result = select(1, &temps, 0, 0, &timeout);
 
  if( result == -1 )
  {
   puts("select 오류 발생");
   exit(1);
  }
  else if( result == 0 )
  {
   puts("시간이 초과되었습니다 : sekect");
  }
  else
  {
   if( FD_ISSET(0, &temps) )
   {
    str_len = read(0, message, BUFSIZE);
    message[str_len] = 0;
    fputs(message, stdout);
   }
  }
 }
}

WAVE FILE의 구조

WAVE 파일은 사운드 파일중에 한 형식으로 윈도우에서 가장 흔하게 쓰이는 파일중에 하나이다. 이번에 이 유령넘이 강좌랍시고 주절 거리는
내용은 이넘의 WAVE 파일을 한번 재생해 보자..는 것이다. WAVE 파일을재생하는데는, 쉽게는 SoundPlay() 함수였던가? .. 한줄이면 족하다...
물론, 지금 이 강좌는 그렇게 한줄이면 끝나는 정도가 아닌, WAVE 파일의 밑바닥부터 꼭대기까지 샅샅히 훑어 내려가며, 그 내부를 마구 파헤쳐
WAVE 파일을 맘대로 주무를 수 있도록 하는 경지?에까지 도달하도록하는것이 목표다.
일단, WAVE 파일이고 머고 간에, 기본적인 공식?부터 알아보고 넘어가도록 하자.사운드라는 것에 대해 깊이 있는 지식을 가지고 있는 사람은
볼 필요가 없겠지만, 어디까지나 처음 시작하는 사람들이 볼 것 이라고가정하고 설명하도록 한다.
WAVE 파일을 재생하면서 가끔 등록정보를 보신 분들은 알겠지만, 대게WAVE 파일의 등록정보라고 하면, 16 Bit , Stereo , 44.1 kHz...  등등
의 정보가 보일것이다. 이게 뭐가 중요하냐고? 중요하다.. 정말 중요하다. 이것으로 WAVE 파일이 시작되는 것이기 때문이다.예를 들어서 다음
과 같은 WAVE 파일이 하나 있다고 보자.

------------------------------------------------------------------
 [어떤 WAVE 파일의 등록정보]

 - 곡명 : 유령이라 불러라!
 - 16 Bit
 - Stereo
 - 44.1 khz
------------------------------------------------------------------

 이 세가지 정보면 WAVE 파일의 모든 것?을 알 수 있다. 일단 이 3가지기본적인 정보만으로 이 WAVE 파일의 초당전송량(Bit/Second)이나,전체

재생시간등을 계산해 보자. (이거 배워두면 정말 좋다..-_-;;..그냥..)

 일단 계산하는 방식은 모두 곱한다. 16 Bit 이므로 16 을 곱하고,스테레오 방식이기 때문에 (스테레오는 채널이 2개 이기때문에, 2를 곱한다

당연히 모노는 1채널이기 때문에 1을 곱하면 된다.... 1은 안곱해도 되는구나 --;) 그리고 44.1 kHz 라는 것은 1초에 44100 번 발광을 한다는

소리니까 44100을 곱하면 된다.
 

16 * 2 * 44100 = 1411200 Bit 다.. 다시 바이트로 고쳐주려면, 나누기 8을 하면 된다. (왜 나누기 8을 하냐고 묻는다면.. 아시다시피.. 8 Bit

는 1 Byte 이기 때문이다..) 나누기 8을 한 결과 176400 이라는 숫자가나왔다.

 즉, 이 WAVE 파일은 초당 176400 Byte 의 용량을 전송한다는 얘기다..숫자가 너무 크다고?.. 다시 KByte로 환산해 보자.. 172.265625가 나오

는데,귀찮으니까 소수점 아랫것들은 잘라버리고 정수부분만 읽어보자면172 KB 라고 나올 것이다. 그렇다. 이 WAVE 파일은 1초에 172 KB 나 차

지한다. (더럽게 크구만..) 전체 재생시간을 구하는 것 역시 간단하다.단순히 나누기만 하면 되기 때문이다.  전체 파일 크기를 알고 있다면,

 " 전체 파일 크기 / 초당 용량 = 전체 재생 시간 (초 단위) "

 라는 공식이 성립되는 것이다.자,이제 자신의 컴퓨터에 들어있는 WAVE들을 모조리 불러다가 그 넘들의 재생시간을 구해보고 실제로 플레이

해본다음 비슷하게 맞는지 비교해 보라.

------------------------------------------------------------------
 여기서, 숙제.. 다음의 WAVE 파일들의 전체 크기는 얼마나 될까??????

 [1]  8 Bit , Mono , 22 kHz
 [2] 16 Bit , Mono , 11 kHz
 [3] 16 Bit , Stereo , 22 KHz

 각각의 WAVE 파일들의 재생시간은 총 1분 30초씩 이다. 그렇다면 각각의 WAVE 파일들의 전체 파일크기는 얼마나 될까?? ( 대한민국 초등교육

과정을 이수한 사람이라면 누구나 풀 수 있는 문제라서 풀이는 생략..)
------------------------------------------------------------------

 WAVE 파일은 대게 8 Bit , 16 Bit 가 많이 쓰이는데, 24, 32 Bit 파일은 별도로 치고.. 대표적인 8 / 16 Bit 파일들은 아래의 그림처럼 파일

에 저장되어 있다. 8 Bit 라면 - 1 Byte 이므로 1 Byte 단위 마다 저장되어 있고, 16 Bit 라면 당연히 2 Byte 마다 저장되어 있다. 아래 그림

을 보면 8 Bit 파일은 전부 16개 (16진수 10까지..) 로 되어 있는 반면 16 Bit 는 같은 크기인데도 8 칸 밖에는 안된다. 이론적으로 16 Bit 는

8 Bit 에 비해 2 배의 용량을 차지하기 때문이다. [ D ] 라고 표기되어있는 것은 본인이 편의상 구분하기 쉽게 [ DATA ] 를 줄여 표현한 것이

고.. ( Mono 는 L / R 구분이 없다 ) Stereo에서 [ L ] , [ R ] 이라고

표기 한 것은 양 채널 ( Left Channel, Right Channel ) 을 뜻 한다...

------------------------------------------------------------------
 [ 8 Bit Mono ]

   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F  10
 +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
 : D : D : D : D : D : D : D : D : D : D : D : D : D : D : D : D :
 +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

 [ 8 Bit Stereo ]

   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F  10
 +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
 : L : R : L : R : L : R : L : R : L : R : L : R : L : R : L : R :
 +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

 [ 16Bit Mono ]
     1       2       3       4       5       6       7       8
 +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
 :   D   :   D   :   D   :   D   :   D   :   D   :   D   :   D   :
 +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

 [16Bit Stereo ]

     1       2       3       4       5       6       7       8
 +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
 :   L   :   R   :   L   :   R   :   L   :   R   :   L   :   R   :
 +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

------------------------------------------------------------------

 이건 어디까지나 2 채널(Stereo)방식만을 봤을때 그렇다는 것이고, 채널이 많아지면 또 저장구조는 당연히 달라지게 된다. 요즘 흔히 말하는

5.1채널이니 7.1채널이니 하는 것들은, 저것과는 모양새가 또 다르다..

------------------------------------------------------------------

 WAVE 파일에 대해서 간략하게나마 알아봤는데,이제부터는 정말 자세히파헤쳐 볼 시간이다. WAVE 파일들은 크게 청크 부분과 데이타 부분으로

나뉜다. 실제 사운드가 들어있는 데이타 부분 앞에는 헤더 청크 부분이있는데, WAVE 파일의 구조를 살펴보면 아래와 같다.

------------------------------------------------------------------
1. Wave 파일 포맷(I)

   1) PCMWAVEFORMAT 구조체의 구조
      -. WAVEFORMAT wf;
      -. WORD       wBitsPerSample;

   2) WAVEFORMAT 구조체의 구조
      -. WORD   wFormatTag;
      -. WORD   nChannels;
      -. DWORD  nSamplesPerSec;
      -. DWORD  nAvgBytesPerSec;
      -. WORD   nBlockAlign;

   3) 예 : 22kHz 샘플링된 8bit 스테레오 Wave 파일의 구조

      PCMWAVEFORMAT PcmWaveFormat;
     
      PcmWaveFormat.wf.wFormatTag = 1;
      PcmWaveFormat.wf.nChannels = 2;      
      PcmWaveFormat.wf.nSamplesPerSec = 22050; 
      PcmWaveFormat.wf.nAvgBytesPerSec = 44100;
      PcmWaveFormat.wf.nBlockAlign = 2;
      PcmWaveFormat.wBitsPerSample = 8;       

2. Wave 파일 포맷(II)
------------------------------------------------------------------
     데이터형 Byte  내용            의미
------------------------------------------------------------------

 1) RIFF chunk 
     - Char   4   "RIFF"          파일의 종류가 RIFF 파일을 의미
     - DWORD  4   FILE SIZE       현재부터 끝까지의 파일크기
                                  (파일크기-4Byte 또는, 데이터 크기
                                   +40Byte)
     - Char   4   "WAVE"          Wave 파일을 의미
  
 2) FMT sub-chunk
     - Char   4   "fmt "          FMT sub-chunk의 시작
     - DWORD  4   16              현재 포인터(16 Byte)
     - short  2   wFormatTag      PCMWAVEFORMAT의 값
                                  ( 1:Wave Format이 PCM 방식 )
     - short  2   nChannels       채널 수 ( 1:모노, 2:스테레오 )
     - DWORD  4   nSamplesPerSec  샘플링 수
                                  ( 11kHz:11025,
                                    22kHz:22050,
                                    44kHz:44100 )
     - DWORD  4   nAvgBytesperSec 초당 샘플바이트
                                  ( nSamplesPerSec*BlockAlign )
     - short  2   BlockAlign      샘플당 바이트( nChannels*비트/8 )
     - short  2   wBitsPerSample  샘플당 비트수

   3) Data sub-chunk
     - Char   4   "data"          데이터청크의 시작
     - DWORD  4   DATA SIZE       데이터의 크기
                  DATA            데이터
------------------------------------------------------------------

 WAVE 파일들을 EDITOR 로 읽어보면 파일의 내용이 아래와 같이 나온다원래는 HEX 값이 나와야 하는데 메모장으로 읽어들였더니..아래처럼 나

왔다.. -_-; 그래도 상관없다. 중요한건 제일 처음 " RIFF " 라는 단어로 시작한다는 것이다. 그 다음에 WAVE 파일 포맷임을 알리는 " WAVE "

라는 단어가 온다. 보통 파일포맷에 따라 헤더에 해당 파일포맷임을 리는 식별자가 오는데 GIF나 PCX, 또는 EXE 파일들을 한번씩 열어 보면

같은 단어로 시작한다는 것을 알 수 있을 것이다.

[1] RIFF$?WAVEfmt D&#52550;Xdata? ...

[2] RIFF?$WAVEfmt D??data? ...

[3] RIFF? WAVEfmt   D  ? PAD ?                                      

                                          
------------------------------------------------------------------              

                   
 3 개의 WAVE 파일들을 열어봤는데, 모두 RIFF .. WAVE .. fmt 로 시작하고 있다.이 파일들이 WAVE 파일임을 알 수 있는 것이다. 사실 WAVE파

일에도 ADPCM 이니 PCM 이니 하는 식으로 다양한?포맷이 존재하는데 이

것은 쉽게 생각하면 압축방식의 차이다.  여기서 RIFF 파일 형식이라는

말이 나오는데, RIFF에 대해서 설명하자면..
          
------------------------------------------------------------------
[ RIFF 파일(Resource Interchange File Format) ]
------------------------------------------------------------------ 
음성이나 비디오 같은 유의 데이터들은 용량이 매우 크기 때문에  이를저장할 시에는 비트 단위보다는 블록 단위로 저장을 하게 된다.

이러한블록은 가변적인 크기를 가질 수 있는데 이를 위해서는 데이터 블록 앞에 헤더를 사용해 이를 정의해 주어야 한다. 일례로

10 MByte 의  음성

데이터를 파일에 저장 하려할 때 블록 단위로 하지 않으면 데이터를 불러오는데 10M의 메모리가 필요하게 된다. 이렇게 된다면 불러오기도 힘

들 뿐만 아니라 불러오는데 걸리는 시간이 많이 걸리는 단점이 생긴다.그러나 10M의 음성데이터를 0.5M 씩 블록으로 나누어 저장한다면 20 개

의 블록을 가질 것이다. 즉, 0.5M씩 메모리에 불러온 후 출력하고,  메모리를 해제한 후 다시 다음 블록을 불러오면 그만큼 메모리도 절약 할

수 있어 매우 편리하게 된다. 또한 데이터 저장 블록 앞에 블록의 데이터 크기를 넣어주는데, 이는 예를 들자면 어느 시간동안 모노로 듣다가

후에 스테레오로 들을 수 있는 상황 등에 대처하기 쉽다. 이럴 때 데이터 블록 앞에 데이터에 대한 정보를 만들어 준다. 각각의 부분 하나 하

나는 청크(Chunk)라고 하고 처음에 나오는 상자를 부모 청크,그 하단에위치하는 부분을 자식 청크, 데이터들은 데이터 청크라고 한다.이와 같

은 구성 데이터를 저장하는 방식을 RIFF라 하고 위와 같은 구성으로 저장된 데이터를 RIFF 파일이라 한다.  WAVE  파일이나 AVI  파일이 바로

RIFF 파일이다.

기타

다음으로 알아두면 앞으로 강좌를 이해하기에 좋을 압축방식들에 대한정보들을 소개한다.

[ PCM(Pulse Code Modulation) 방식 ]

이 방식은 가장 널리 사용되는 방식으로서 음성을 아날로그에서 디지털로 변환하여 양자화(작은 단위화)한 데이터를 그대로 저장한 후 재생할

때에는 그 데이터를 디지털에서 아날로그로 재변환하여 음성 파형을 만든다. 이 방식은 양자화를 할 때 생기는 오차가 존재하지만 재생 시 상

당히 우수한 품질을 가진다.이 방식의 특징은 제로 크로스의 방법에 비해 생성되는 데이터의 양이 많다는 점이다.예를 들어, 샘플링 주파수를

8Khz로 하고 양자화 시 정밀도를 8bit로 하면 8000 * 8 = 64000/sec = 64Kbit/sec로 초당 64KB가 생성된다. 그러나 최근에는 메모리의 가격이

많이 떨어지고 있어서 뛰어난 음성 품질을 보장할수 있는 PCM방식을 많이 사용하고 있다.

[ DM(Delta Modulation) 방식 ]

DM 방식은 제로 크로스 방식과 PCM 방식의 중간적인 형태로 볼 수 있다이 방식은 어느 시점n의 파고와 바로 전 시점 (n-1)의 파고를 비교하여

그 차이점을 1,0,-1로 표현한다. DM 방식의 단점은 원파형의 급격한 변화를 따라가지 못한다는 것이다. DM 방식의 하드웨어 구현은 바로 이전

값에 1 또는 -1을 더하기만 하면 되므로 아주 간단하다.

[ DPCM(Differencial PCM) 방식 ]

우리의 음성 파형을 실제로 보면, 서로 인접한 샘플링 시점의 비교에서파형이 크게 변하지 않는다. 이점에 착안하여 만든 방식이 DPCM 방식이

다. DPCM 방식은 개선된 PCM 방식이라 할 수 있다. 즉,  PCM 방식은 파고 값을 그대로 저장하지만 DPCM  방식은 이전의 값과의 차이만을 저장

하는 것이다.  음성의 파형이 크게 변하지 않으므로 차이값도 작아져서 bit-rate를 낮출 수 있다.

[ ADPCM(Adaptive Differencial PCM) 방식 ]

ADPCM 방식은 위의 여러 가지 방식의 단점을 보완한 것이다. DM 방식이나 DPCM 방식은 압축된 비트수로 표현 되는 최대의 변화량이 실제 파형

의 변화량보다 작기 때문에 실제로 구현하면 재생 파형이 원 파형의 급격한 변화를 나타내지 못한다. 이를 막기 위하여 양자화할때 시간 간격

을 작게 하면 bit-rate를 증가시키는 결과를 가져오게 된다.ADPCM 방식은 파형의 변화량이 급격히 변할 때는 양자화 할 때의 단위를 크게하여

차분값을 이용하는 것으로 파형의 진폭이 클경우 약간의 잡음이 있어도 사람이 잘 감지하지 못하는 점을 이용한 것이다.

C++ 프리프로세서 명령

16.1 서론

16.2 C++ 프리프로세서

16.3 파일의 include

16.4 단순한 문자열 치환

16.5 인수 없는 매크로

16.6 인수 있는 매크로

16.7 매크로 정의 해체

16.8 조건 컴파일러

16.9 #pragma

16.10 정리

 ◈ 16.2 C++프리프로세서

-C++프리프로세서 명령의 규칙은 C와 동일

-프리프로세서는 컴파일러에 넘겨주시 전에 프로그램의 소스 코드를 처리하는 프로그램이다.

-프리프로세서 명령은 기호 #이 앞에 놓여지고 프리프로세서 제어행이라고 부름.

-제어행의 내용에 따라 하나 또는 그 이상의 기능을 실행함.

■파일의 include

-다음이 있으면 파일이 include됨

■문자열의 치환, 매크로 전개나 정의해제

-문자열의 치환, 매크로 전개나 정의해제 기능은, 다음의 명령으로 구현됨

■조건 컴파일의 명령

-조건 컴파일은, 다음의 제어행을 조합해서 구현됨

■디버그 작업의 보조

-다음의 제어행은 디버그를 지원함.

 ◈ 16.3 파일의 include(1)

-오류 매시지

 ◈ 16.3 파일의 include(2)

-실행 결과

-#include 명령은 컴파일 시에 명령 뒤에 있는 파일명의 모든 내용을 include함.

-헤더 파일 iostream.h는 cout의 정의를, stdio.h는 printf()의 정의를 포함

-#include 명령의 3가지 형식

￭#include <filename>

 ∙<>괄호 안의 파일명은 컴파일러에게 현재의 작업 디렉토리 이외의 미리 준비된 디렉토리(표준 디렉토리)의 리스트로부터 그 파일을 찾도록 지시

￭#include “filename”

∙컴파일러에게 현재의 작업 디렉토리 내에서 그 파일을 찾도록 지시

￭#include “c:\wkspace\kdhong\"filename”

∙컴파일러에게 지정된 경로 내에서 그 파일을 찾도록 지시, 그 디렉토리에서 발견되지 않으면 표준 디렉토리를 찾음.

-가령, D:\Lecture2K-2\C++\nykwak.h에 int a = 5;라는 선언문이 삽입되어 있을 경우, 실행 결과는, 다음과 같다.

 ◈ 16.3 파일의 include(3)

-가령, D:\Lecture2K-2\C++\kdhong.h에

int a = 5

라는 선언문이 삽입되어 있을 경우, 메러 메시지는, 다음과 같다.

 ◈ 16.4 단순한 문자열 치환

-일반적으로, #define 제어행을 사용할 때, 대문자를 사용.(그 이유는 프로그램 중에서 #define되는 변수를 쉽게 확인할 수 있기 때문.)

-실행 결과

 ◈ 16.5 인수 없는 매크로

-실행 결과

-다음 제어행 중,

#define는 제어행으로, SQUARE_TWO는 매크로 템플리트이고, 2*2는 매크로 전개임.

 ◈ 16.6 인수 있는 매크로(1)

-실행 결과

 ◈ 16.6 인수 있는 매크로(2)

-오류 메시지

 ◈ 16.6 인수 있는 매크로(3)

-실행 결과

-test16_9.cpp의 동작 설명

즉, 곱셈은 덧셈보다 연산우선순위가 빠르기 때문에 다음과 같이 계산됨

그러나, 기대했던 것은 다음과 같은 것임.

(따라서, 괄호를 생략해서는 안됨)

 ◈ 16.7 매크로 정의 해제

-이미 정의된 (#define) 매크로는 다음과 같은 제어행으로 정의를 해제할 수 있음.

-오류 메시지

-메크로를 해제하는 이유는, 매크로 명을 필요로 하는 코드 부분만으로 유효 범위를 한정하기 위함.

 ◈ 16.8 조건 컴파일러

-조건 컴파일러는 소스 코드 중의 다음 키워드가 발견되면 수행됨.

16.8.1 #if - #else - #endif(1)

-키워드 #if에는 상수식, 코드블록이 이어지고, 그 뒤에 키워드 #endif가 놓여짐.

-실행 결과

16.8.1 #if - #else - #endif(2)

-실행 결과

16.8.1 #if - #else - #endif(3)

-실행 결과

16.8.1 #if - #else - #endif(4)

#if-#else-#endif와 정규 if-else-endif 제어 구조의 차이는, 전자에서는 case 평가를 프로그램이 컴파일되기 이전에 한다는 점이다. 테스트 조건 안에 변수를 두어서는 안된다. 왜냐하면, 변수의 값은 실행중에 변할 수도 있기 때문.

16.8.2 #if - #elif - #endif

#if-#elif-#endif는 #if-#else-#endif와 유사

-실행 결과

16.8.3 #ifdef-#endif

-2개의 제어행 사이의 코드 블록은, 명령의 뒤에 있는 매크로명이 그 앞에 정의되어 있을 때에만 컴파일됨.

-실행 결과

16.8.4 #ifndef-#endif

-#indef-#endif문의 반대로, 제어행 사이 코드블록은, 매크로 명이 정의되어 있지 않을 때만 컴파일됨.

-실행 결과

 ◈ 16.#pragma

-이 제어행은 컴파일러에 여러 가지 지령을 줄 수 있다. 특수한 지령은 처리계의 독자적인 지령이다.

MSDNdpt의 progma에 대한 설명

Each implementation of C and C++ supports some features unique to its host machine or operating system. Some programs, for instance, need to exercise precise control over the memory areas where data is placed or to control the way certain functions receive parameters. The #pragma directives offer a way for each compiler to offer machine- and operating-system-specific features while retaining overall compatibility with the C and C++ languages. Pragmas are machine- or operating-system-specific by definition, and are usually different for every compiler.

Syntax

#pragma token-string

The token-string is a series of characters that gives a specific compiler instruction and arguments, if any. The number sign (#) must be the first non-white-space character on the line containing the pragma; white-space characters can separate the number sign and the word pragma. Following #pragma, write any text that the translator can parse as preprocessing tokens. The argument to #pragma is subject to macro expansion.

If the compiler finds a pragma it does not recognize, it issues a warning, but compilation continues.

Pragmas can be used in conditional statements, to provide new preprocessor functionality, or to provide implementation-defined information to the compiler. The C and C++ compilers recognize the following pragmas:

alloc_text comment init_seg1 optimize

auto_inline component inline_depth pack

bss_seg data_seg inline_recursion pointers_to_members1

check_stack function intrinsic setlocale

code_seg hdrstop message vtordisp1

const_seg include_alias once warning