Subversion Repositories djpeg

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

// JPEGデコード

// 2005年10月26日 V1.0 

// All Rights Reserved, Copyright (c) Hidemi Ishihara

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

//

// JPEGを入力するとBitmapを出力します。

// 

// % gcc -o djpeg fjpeg.c

// % djpeg 入力ファイル名　出力ファイル名

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

#include <stdio.h>

#include <stdlib.h>

unsigned int BuffIndex;  // JPEGデータの位置

unsigned int BuffSize;   // JPEGデータの大きさ

unsigned int BuffX;      // 画像の横サイズ

unsigned int BuffY;      // 画像の縦サイズ

unsigned int BuffBlockX; // MCUの横個数

unsigned int BuffBlockY; // MCUの縦個数

unsigned char *Buff;     // 伸長したデータを入れるバッファ

unsigned char  TableDQT[4][64];  // 量子化テーブル

unsigned short TableDHT[4][162]; // ハフマンテーブル

unsigned short TableHT[4][16]; // ハフマンスタートテーブル

unsigned char  TableHN[4][16]; // ハフマンスタート番号

unsigned char BitCount = 0; // 圧縮データの読み込み位置

unsigned int LineData;      // 伸長に使うデータ

unsigned int NextData;      // 伸長に使うデータ

unsigned int PreData[3]; // DC成分用の貯めバッファ

// ジグザグテーブル

int zigzag_table[]={

     0, 1, 8, 16,9, 2, 3,10,

    17,24,32,25,18,11, 4, 5,

    12,19,26,33,40,48,41,34,

    27,20,13, 6, 7,14,21,28,

    35,42,49,56,57,50,43,36,

    29,22,15,23,30,37,44,51,

    58,59,52,45,38,31,39,46,

    53,60,61,54,47,55,62,63,

};

typedef unsigned short WORD;

typedef unsigned long DWORD;

typedef long LONG;

typedef struct tagBITMAPFILEHEADER {

  WORD    bfType;

  DWORD   bfSize;

  WORD    bfReserved1;

  WORD    bfReserved2;

  DWORD   bfOffBits;

} BITMAPFILEHEADER, *PBITMAPFILEHEADER;

typedef struct tagBITMAPINFOHEADER{

  DWORD  biSize;

  LONG   biWidth;

  LONG   biHeight;

  WORD   biPlanes;

  WORD   biBitCount;

  DWORD  biCompression;

  DWORD  biSizeImage;

  LONG   biXPelsPerMeter;

  LONG   biYPelsPerMeter;

  DWORD  biClrUsed;

  DWORD  biClrImportant;

} BITMAPINFOHEADER, *PBITMAPINFOHEADER;

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

// Bitmapを出力する

// file: ファイル名

// x,y:  画像のサイズ

// b:    バイトカウント(1ドット辺りのバイト数)

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

void BmpSave(unsigned char *file,unsigned char *buff,

             unsigned int x,unsigned int y,unsigned int b){

  BITMAPFILEHEADER lpBf;

  BITMAPINFOHEADER lpBi;

  unsigned char tbuff[4];

  FILE *fp;

  unsigned char str;

  int i,k;

  if((fp = fopen(file,"wb")) == NULL){

    perror(0);

    exit(0);

  }

  // ファイルヘッダの設定

  tbuff[0] = 'B';

  tbuff[1] = 'M';

  fwrite(tbuff,2,1,fp);

  tbuff[3] = ((14 +40 +x *y *b) >> 24) & 0xff;

  tbuff[2] = ((14 +40 +x *y *b) >> 16) & 0xff;

  tbuff[1] = ((14 +40 +x *y *b) >>  8) & 0xff;

  tbuff[0] = ((14 +40 +x *y *b) >>  0) & 0xff;

  fwrite(tbuff,4,1,fp);

  tbuff[1] = 0;

  tbuff[0] = 0;

  fwrite(tbuff,2,1,fp);

  fwrite(tbuff,2,1,fp);

  tbuff[3] = 0;

  tbuff[2] = 0;

  tbuff[1] = 0;

  tbuff[0] = 54;

  fwrite(tbuff,4,1,fp);

  // インフォメーションの設定

  lpBi.biSize            = 40;

  lpBi.biWidth           = x;

  lpBi.biHeight          = y;

  lpBi.biPlanes          = 1;

  lpBi.biBitCount        = b*8;

  lpBi.biCompression     = 0;

  lpBi.biSizeImage       = x*y*b;

  lpBi.biXPelsPerMeter   = 300;

  lpBi.biYPelsPerMeter   = 300;

  lpBi.biClrUsed         = 0;

  lpBi.biClrImportant    = 0;

  fwrite(&lpBi,1,40,fp);

  // 上下反転

  for(k=0;k<y/2;k++){

    for(i=0;i<x*3;i++){

      str = buff[k*x*3+i];

      buff[k*x*3+i] = buff[((y-1)*x*3 -k*x*3) +i];

      buff[((y-1)*x*3-k*x*3) +i] = str;

    }

  }

  fwrite(buff,1,x*y*b,fp);

  fclose(fp);

}

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

// 1Byte取得

unsigned char get_byte(unsigned char *buff){

  if(BuffIndex >= BuffSize) return 0;

  return buff[BuffIndex++];

}

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

// 2Byte取得

unsigned short get_word(unsigned char *buff){

  unsigned char h,l;

  h = get_byte(buff);

  l = get_byte(buff);

  return (h<<8)|l;

}

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

// 32bitデータ取得(伸長時のみ使用する)

unsigned int get_data(unsigned char *buff){

  unsigned char str = 0;

  unsigned int data = 0;

  str = get_byte(buff);

  if(str ==0xff) if(get_byte(buff)== 0x00) str = 0xFF; else str = 0x00;

  data = str;

  str = get_byte(buff);

  if(str ==0xff) if(get_byte(buff)== 0x00) str = 0xFF; else str = 0x00;

  data = (data << 8) | str;

  str = get_byte(buff);

  if(str ==0xff) if(get_byte(buff)== 0x00) str = 0xFF; else str = 0x00;

  data = (data << 8) | str;

  str = get_byte(buff);

  if(str ==0xff) if(get_byte(buff)== 0x00) str = 0xFF; else str = 0x00;

  data = (data << 8) | str;

  //printf(" Get Data: %08x\n",data);

  return data;

}

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

// APP0処理

void GetAPP0(unsigned char *buff){

  unsigned short data;

  unsigned char str;

  unsigned int i;

  data = get_word(buff); // Lp(レングス)

  // APP0は読まなくてもいいので取り合えずレングス分スキップする

  for(i=0;i<data-2;i++){

    str = get_byte(buff);

  }

  /*

  str = get_byte(buff);  // 識別子(5文字,"JFIF"と[00])

  str = get_byte(buff);

  str = get_byte(buff);

  str = get_byte(buff);

  str = get_byte(buff);

  data = get_word(buff); // バージョン

  str = get_byte(buff);  // 解像度の単位

  data = get_word(buff); // 横方向の解像度

  data = get_word(buff); // 縦方向の解像度

  data = get_word(buff); // サムネイルの横ピクセル数

  data = get_word(buff); // サムネイルの縦ピクセル数

  data = get_word(buff); // サムネイルデータ(ある場合だけ)

  */

}

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

// DQT処理

void GetDQT(unsigned char *buff){

  unsigned short data;

  unsigned char str;

  unsigned int i;

  unsigned int tablenum;

  data = get_word(buff);

  str = get_byte(buff); // テーブル番号

  //printf("*** DQT Table %d\n",str);

  for(i=0;i<64;i++){

    TableDQT[str][i] = get_byte(buff);

    //printf(" %2d: %2x\n",i,TableDQT[str][i]);

  }

}

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

// DHT処理

void GetDHT(unsigned char *buff){

  unsigned short data;

  unsigned char str;

  unsigned int i;

  unsigned char max,count;

  unsigned short ShiftData = 0x8000,HuffmanData =0x0000;

  unsigned int tablenum;

  data = get_word(buff);

  str = get_byte(buff);

  switch(str){

  case 0x00:

    tablenum = 0x00;

    break;

  case 0x10:

    tablenum = 0x01;

    break;

  case 0x01:

    tablenum = 0x02;

    break;

  case 0x11:

    tablenum = 0x03;

    break;

  }

  //printf("*** DHT Table/Number %d\n",tablenum);

  // テーブルを作成する

  max = 0;

  for(i=0;i<16;i++){

    count = get_byte(buff);

    TableHT[tablenum][i] = HuffmanData;

    TableHN[tablenum][i] = max;

    //printf(" %2d: %4x,%2x\n",i,TableHT[tablenum][i],TableHN[tablenum][i]);

    max = max + count;

    while(!(count==0)){

      HuffmanData += ShiftData;

      count--;

    }

    ShiftData = ShiftData >> 1; // 右に1bitシフトする

  }

  //printf("*** DHT Table %d\n",tablenum);

  for(i=0;i<max;i++){

    TableDHT[tablenum][i] = get_byte(buff);

    //printf(" %2d: %2x\n",i,TableDHT[tablenum][i]);

  }

}

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

// SOF処理

void GetSOF(unsigned char *buff){

  unsigned short data;

  unsigned char str;

  unsigned int i;

  unsigned char count;

  data = get_word(buff);

  str = get_byte(buff);

  BuffY = get_word(buff); // 画像の横サイズ

  BuffX = get_word(buff); // 画像の縦サイズ

  count = get_byte(buff); // データのコンポーネント数

  for(i=0;i<count;i++){

    str = get_byte(buff); // コンポーネント番号

    str = get_byte(buff); // サンプリング比率

    str = get_byte(buff); // DQTテーブル番号

  }

  // MCUのサイズを算出する

  BuffBlockX = (int)(BuffX /16);

  if(BuffX % 16 >0) BuffBlockX++;

  BuffBlockY = (int)(BuffY /16);

  if(BuffY % 16 >0) BuffBlockY++;

  Buff = (unsigned char*)malloc(BuffBlockY*16*BuffBlockX*16*3);

  //printf(" size : %d x %d,(%d x %d)\n",BuffX,BuffY,BuffBlockX,BuffBlockY);

}

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

// SOS処理

void GetSOS(unsigned char *buff){

  unsigned short data;

  unsigned char str;

  unsigned int i;

  unsigned char count;

  data = get_word(buff);

  count = get_byte(buff);

  for(i=0;i<count;i++){

    str = get_byte(buff);

    str = get_byte(buff);

  }

  str = get_byte(buff);

  str = get_byte(buff);

  str = get_byte(buff);

}

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

// ハフマンデコード＋逆量子化＋逆ジグザグ

void HuffmanDecode(unsigned char *buff, unsigned char table, int *BlockData){

  unsigned int data;

  unsigned char zero;

  unsigned short code,huffman;

  unsigned char count =0;

  unsigned int BitData;

  unsigned int i;

  unsigned char tabledqt,tabledc,tableac,tablen;

  unsigned char ZeroCount,DataCount;

  int DataCode;

  for(i=0;i<64;i++) BlockData[i] = 0x0; // データのリセット

  // テーブル番号を設定する

  if(table ==0x00){

    tabledqt =0x00;

    tabledc =0x00;

    tableac =0x01;

  }else if(table ==0x01){

    tabledqt =0x01;

    tabledc  =0x02;

    tableac  =0x03;

  }else{

    tabledqt =0x01;

    tabledc  =0x02;

    tableac  =0x03;

  }

  count = 0; // 念のために

  while(count <64){

    // ビットカウントの位置が32を越えた場合、新たにデータを取得する

    if(BitCount >=32){

      LineData = NextData;

      NextData = get_data(buff);

      BitCount -= 32;

    }

    // Huffmanデコードで使用するデータに置き換える

    if(BitCount >0){

      BitData = (LineData << BitCount) | (NextData >> (32 - BitCount));

    }else{

      BitData = LineData;

    }

    //printf(" Haffuman BitData(%2d,%2d): %8x\n",table,count,BitData);

    // 使用するテーブルのセレクト

    if(count ==0) tablen = tabledc; else tablen = tableac;

    code = (unsigned short)(BitData >> 16); // コードは16ビット使用する

    // ハフマンコードがどのビット数にいるか割り出す

    for(i=0;i<16;i++) {

      //printf(" Haff hit(%2d:%2d): %8x,%8x\n",table,i,TableHT[tablen][i],code);

      if(TableHT[tablen][i]>code) break;

    }

    i--;

    code    = (unsigned short)(code >> (15 - i)); // コードの下位を揃える

    huffman = (unsigned short)(TableHT[tablen][i] >> (15 - i));

    //printf(" PreUse Dht Number(%2d): %8x,%8x,%8x\n",i,code,huffman,TableHN[tablen][i]);

    // ハフマンテーブルの場所を算出する

    code = code - huffman + TableHN[tablen][i];

    //printf(" Use Dht Number: %8x\n",code);

    ZeroCount = (TableDHT[tablen][code] >> 4) & 0x0F; // ゼロレングスの個数

    DataCount = (TableDHT[tablen][code]) & 0x0F;      // 続くデータのビット長

    //printf(" Dht Table: %8x,%8x\n",ZeroCount,DataCount);

    // ハフマンコードを抜き、続くデータを取得する

    DataCode  = (BitData << (i + 1)) >> (16 + (16 - DataCount));

    // 先頭ビットが"0"であれば負のデータ、上位ビットに１を立てて、１を足す

    //if(!(DataCode & (1<<(DataCount-1)))) DataCode=DataCode-(1<<DataCount)+1;

    if(!(DataCode & (1<<(DataCount-1))) && DataCount !=0){

      DataCode |= (~0) << DataCount;

      DataCode += 1;

    }

    //printf(" Use Bit: %d\n",(i + DataCount +1));

    BitCount += (i + DataCount +1); // 使用したビット数を加算する

    if(count ==0){

      // DC成分の場合、データとなる

      if(DataCount ==0) DataCode =0x0; // DataCountが0ならデータは0である

      PreData[table] += DataCode; // DC成分は加算しなければならない

      // 逆量子化＋ジグザグ

      BlockData[zigzag_table[count]] =PreData[table]*TableDQT[tabledqt][count];

      count ++;

    }else{

      if(ZeroCount == 0x0 && DataCount == 0x0){

        // AC成分でEOB符号が来た場合は終了する

        break;

      }else if(ZeroCount ==0xF && DataCount == 0x0){

        // ZRL符号が来た場合、15個のゼロデータとみなす

        count += 15;

      }else{

        count += ZeroCount;

        // 逆量子化＋ジグザグ

        BlockData[zigzag_table[count]] = DataCode * TableDQT[tabledqt][count];

      }

      count ++;

    }

  }

}

const int C1_16 = 4017; // cos( pi/16) x4096

const int C2_16 = 3784; // cos(2pi/16) x4096

const int C3_16 = 3406; // cos(3pi/16) x4096

const int C4_16 = 2896; // cos(4pi/16) x4096

const int C5_16 = 2276; // cos(5pi/16) x4096

const int C6_16 = 1567; // cos(6pi/16) x4096

const int C7_16 = 799;  // cos(7pi/16) x4096

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

// 逆DCT

void DctDecode(int *BlockIn, int *BlockOut){

  int i;

  int s0,s1,s2,s3,s4,s5,s6,s7;

  int t0,t1,t2,t3,t4,t5,t6,t7;

  /*

  printf("-----------------------------\n");

  printf(" iDCT(In)\n");

  printf("-----------------------------\n");

  for(i=0;i<64;i++){

    printf("%2d: %8x\n",i,BlockIn[i]);

  }

  */

  for(i=0;i<8;i++) {

    s0 = (BlockIn[0] + BlockIn[4]) * C4_16;

    s1 = (BlockIn[0] - BlockIn[4]) * C4_16;

    s3 = (BlockIn[2] * C2_16) + (BlockIn[6] * C6_16);

    s2 = (BlockIn[2] * C6_16) - (BlockIn[6] * C2_16);

    s7 = (BlockIn[1] * C1_16) + (BlockIn[7] * C7_16);

    s4 = (BlockIn[1] * C7_16) - (BlockIn[7] * C1_16);

    s6 = (BlockIn[5] * C5_16) + (BlockIn[3] * C3_16);

    s5 = (BlockIn[5] * C3_16) - (BlockIn[3] * C5_16);

    /*

    printf("s0:%8x\n",s0);

    printf("s1:%8x\n",s1);

    printf("s2:%8x\n",s2);

    printf("s3:%8x\n",s3);

    printf("s4:%8x\n",s4);

    printf("s5:%8x\n",s5);

    printf("s6:%8x\n",s6);

    printf("s7:%8x\n",s7);

    */

    t0 = s0 + s3;

    t3 = s0 - s3;

    t1 = s1 + s2;

    t2 = s1 - s2;

    t4 = s4 + s5;

    t5 = s4 - s5;

    t7 = s7 + s6;

    t6 = s7 - s6;

    /*

    printf("t0:%8x\n",t0);

    printf("t1:%8x\n",t1);

    printf("t2:%8x\n",t2);

    printf("t3:%8x\n",t3);

    printf("t4:%8x\n",t4);

    printf("t5:%8x\n",t5);

    printf("t6:%8x\n",t6);

    printf("t7:%8x\n",t7);

    */

    s6 = (t5 + t6) * 181 / 256; // 1/sqrt(2)

    s5 = (t6 - t5) * 181 / 256; // 1/sqrt(2)

    /*

    printf("s5:%8x\n",s5);

    printf("s6:%8x\n",s6);

    */

    *BlockIn++ = (t0 + t7) >> 11;

    *BlockIn++ = (t1 + s6) >> 11;

    *BlockIn++ = (t2 + s5) >> 11;

    *BlockIn++ = (t3 + t4) >> 11;

    *BlockIn++ = (t3 - t4) >> 11;

    *BlockIn++ = (t2 - s5) >> 11;

    *BlockIn++ = (t1 - s6) >> 11;

    *BlockIn++ = (t0 - t7) >> 11;

  }

  BlockIn -= 64;

  /*

  printf("-----------------------------\n");

  printf(" iDCT(Middle)\n");

  printf("-----------------------------\n");

  for(i=0;i<64;i++){

    printf("%2d: %8x\n",i,BlockIn[i]);

  }

  */

  for(i=0;i<8;i++){

    s0 = (BlockIn[ 0] + BlockIn[32]) * C4_16;

    s1 = (BlockIn[ 0] - BlockIn[32]) * C4_16;

    s3 = BlockIn[16] * C2_16 + BlockIn[48] * C6_16;

    s2 = BlockIn[16] * C6_16 - BlockIn[48] * C2_16;

    s7 = BlockIn[ 8] * C1_16 + BlockIn[56] * C7_16;

    s4 = BlockIn[ 8] * C7_16 - BlockIn[56] * C1_16;

    s6 = BlockIn[40] * C5_16 + BlockIn[24] * C3_16;

    s5 = BlockIn[40] * C3_16 - BlockIn[24] * C5_16;

    /*

    printf("s0:%8x\n",s0);

    printf("s1:%8x\n",s1);

    printf("s2:%8x\n",s2);

    printf("s3:%8x\n",s3);

    printf("s4:%8x\n",s4);

    printf("s5:%8x\n",s5);

    printf("s6:%8x\n",s6);

    printf("s7:%8x\n",s7);

    */

    t0 = s0 + s3;

    t1 = s1 + s2;

    t2 = s1 - s2;

    t3 = s0 - s3;

    t4 = s4 + s5;

    t5 = s4 - s5;

    t6 = s7 - s6;

    t7 = s6 + s7;

    /*

    printf("t0:%8x\n",t0);

    printf("t1:%8x\n",t1);

    printf("t2:%8x\n",t2);

    printf("t3:%8x\n",t3);

    printf("t4:%8x\n",t4);

    printf("t5:%8x\n",t5);

    printf("t6:%8x\n",t6);

    printf("t7:%8x\n",t7);

    */

    s5 = (t6 - t5) * 181 / 256; // 1/sqrt(2)

    s6 = (t5 + t6) * 181 / 256; // 1/sqrt(2)

    /*

    printf("s5:%8x\n",s5);

    printf("s6:%8x\n",s6);

    */

    BlockOut[ 0] = ((t0 + t7) >> 15);

    BlockOut[56] = ((t0 - t7) >> 15);

    BlockOut[ 8] = ((t1 + s6) >> 15);

    BlockOut[48] = ((t1 - s6) >> 15);

    BlockOut[16] = ((t2 + s5) >> 15);

    BlockOut[40] = ((t2 - s5) >> 15);

    BlockOut[24] = ((t3 + t4) >> 15);

    BlockOut[32] = ((t3 - t4) >> 15);

    BlockIn++;

    BlockOut++;

  }

  BlockOut-=8;

  /*

  printf("-----------------------------\n");

  printf(" iDCT(Out)\n");

  printf("-----------------------------\n");

  for(i=0;i<8;i++){

    printf(" %2d: %04x;\n",i+ 0,BlockOut[i+ 0]&0xFFFF);

    printf(" %2d: %04x;\n",i+56,BlockOut[i+56]&0xFFFF);

    printf(" %2d: %04x;\n",i+ 8,BlockOut[i+ 8]&0xFFFF);

    printf(" %2d: %04x;\n",i+48,BlockOut[i+48]&0xFFFF);

    printf(" %2d: %04x;\n",i+16,BlockOut[i+16]&0xFFFF);

    printf(" %2d: %04x;\n",i+40,BlockOut[i+40]&0xFFFF);

    printf(" %2d: %04x;\n",i+24,BlockOut[i+24]&0xFFFF);

    printf(" %2d: %04x;\n",i+32,BlockOut[i+32]&0xFFFF);

  }

  */

}

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

// 4:1:1のデコード処理

void Decode411(unsigned char *buff, int *BlockY, int *BlockCb, int *BlockCr){

  int BlockHuffman[64];

  int BlockYLT[64];

  int BlockYRT[64];

  int BlockYLB[64];

  int BlockYRB[64];