众所周知，bing搜索网站首页每日会更新一张图片，张张漂亮（额，也有一些不合我口味的），特别适合用来做电脑壁纸。

我们想要将bing网站背景图片设置为电脑桌面背景的通常做法是：

  • 上网，搜索bing
  • 找到图片的下载链接，并下载之
  • 将图片设置为桌面背景（也有部分浏览器支持直接在网页中右击图片设置为壁纸）
  • 可能你还会删除下载下来的图片

作为一枚coder，你不会觉得麻烦嘛？至少需要三个步骤呢！

So...我就用C++语言写了一个小程序，用于获取bing网站的图片，并将其设置为桌面背景。整个过程只需要点击.exe文件，一键完成！

当然，你也可以通过本程序，窥见Windows API的些许用法，活学活用C++知识！

当然网上也存在片片断断的程序，我的部分程序也借鉴了它们的思想，在此感谢互联网和辛勤的贡献者们。

以下是程序设计的技术要点：

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

技术要点：

  1.     1、获取网络地址   直接使用网络地址或下载 注意若下载下来后，要将\转换为/,当然也可以用\\
  1.        网络地址可以从这里获取：http://cn.bing.com/HPImageArchive.aspx?format=xml&idx=0&n=1
  1.        在返回的xml页面中(images->image->url)找到具体的图片地址(xml解析)，拼接到bing域名后面构成完整地址
  1.        注：xml解析用了TinyXml2
  1.  
  1.     2、转换图片格式(jpg->bmp)，本程序中的SystemParametersInfoA函数只支持bmp
  1.        在程序中自动转换(单单改后缀名是没有用的)，转换用的程序是从网上下载的，用C语言编写而成
  1.        考虑到需要改后缀名，那就直接下载图片好了，顺便存储之
  1.  
  1.     3、图片保存路径为C:/Users/Administrator/bingPicture/,格式为.jpg 方便以后浏览
  2.  
  3.        注意：部分用户电脑可能不存在路径C:/Users/Administrator/,造成程序无法执行，可以直接在C盘根目录下创建路径，如C:/bingPicture/
  1.        注意不保存转换后的bmp格式图片(设置背景后即删除)，因为体积较大
  1.        判断文件夹是否存在，若不存在，则自动创建文件夹
  2.  
  3.     4、注意本程序获取的图片尺寸是1366x768，若你的屏幕分辨率为1920x1080，还需要对Xml解析出来的图片Url地址进行字符串替换（将1366x768换成1920x1080即可）
  4.  
  5.        前提：针对1920x1080尺寸的图片地址存在
  6.  
  7.     5、若此程序若在国际网络下运行，获取的就是国际版bing壁纸；若在国内网络下运行，获取的就是中国版bing壁纸。因此在同一天内，在不同网络环境下获取的图片可能不同
  1.  
  1. *未实现的功能*：
  1.     1、获取每日壁纸的故事(利用bing故事接口) ，更新壁纸后显示在执行框中
  1.  
  1.     2、开机自启动，并隐藏到托盘中(为减少CPU占用并增加趣味性，设置为开机自动启动，提示网络连接，并输入"go"才执行功能)
  1.        电脑若未关机，则在24:00自动启动，更换背景
  1.  
  1.     3、软件自动更新版本功能

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

程序在文章后面提供，源码已注释很详细，不再赘述。

注意，使用程序之前，务必看以下注意事项：

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

请注意：
    1、本软件使用Qt开发，您也可以将文件加入自己的工程，使用其他IDE开发
         需要注意的一点是，本软件需要加入URLMON.DLL（源码包中有）

2、本软件开源(源码位于xiaoxi666的博客园以及github，不对其他地址给出的链接负责)，仅用于学习交流，请勿用于商业用途

3、为防止软件被加入恶意功能，不提供可执行文件，若需使用请重新编译，编译器需要支持c++11

4、本软件程序中内含删除临时文件功能，请在更改前仔细确认，避免路径错误而删除其他重要文件

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

然而许多小伙伴要体验效果，我就一并把可执行文件放出来吧（请勿随意传播.exe文件防止有人添加恶意功能。当然源码开放可共享）

下载区：

但一定要注意核对文件校验码（以保证安全）：

  • 可执行文件压缩包WallPaper校验码

　　　　MD5: 48173BA7DCF2120F2822226A5D4A90CF
           SHA1: CEB0ED570AF613EC3829AC8FDE4F8C50DDEF4101

  • 可执行文件WallPaper_1366x768_Common校验码(此版本用于1366x768分辨率)

　　　　MD5: ACDA8E5E4CF0B2916254B233D1243FD3
　　     SHA1: 6041C813DC8E2AE29EA8675EF279CFC0E7921D53

  • 可执行文件WallPaper_1920x1080_Common校验码(此版本用于1920x1080分辨率)

　　　　MD5: 474570808A56EFDC7B589F605D08C5B6
　　      SHA1: B78921AD655B35F079076904A22F1A0E5122EB7F

为方便浏览，贴出主要源程序：

main.cpp文件

  1.  //main.cpp
  2.  /******************windows桌面背景更换C++程序***********************************************************
  3.  功能：获取每日bing搜索主页图片，设置为当日桌面壁纸。并将其下载保存至本地文件夹方便以后浏览
  4.  作者：xiaoxi666
  5.  日期：2017/03/12
  6.  
  7.  技术要点：
  8.      1、获取网络地址   直接使用网络地址或下载 注意若下载下来后，要将\转换为/,当然也可以用\\
  9.         网络地址可以从这里获取：http://cn.bing.com/HPImageArchive.aspx?format=xml&idx=0&n=1
  10.         在返回  的xml页面中(images->image->url)找到具体的图片地址(xml解析)，拼接到bing域名后面，构成完整地址
  11.         注：xml解析用了TinyXml2
  12.  
  13.      2、转换图片格式(jpg->bmp)，本程序中的SystemParametersInfoA函数只支持bmp
  14.         在程序中自动转换(单单改后缀名是没有用的)，转换用的程序是从网上下载的，用C语言编写而成
  15.         考虑到需要改后缀名，那就直接下载图片好了，顺便存储之
  16.  
  17.      3、图片保存路径为C:\bingPicture\,格式为.jpg 方便以后浏览
  18.         注意不保存转换后的bmp格式图片(设置背景后即删除)，因为体积较大
  19.         判断文件夹是否存在，若不存在，则自动创建文件夹
  20.  
  21.  *未实现的功能*：
  22.      ***获取每日壁纸的故事(利用bing故事接口) ，更新壁纸后显示在执行框中
  23.  
  24.      ***开机自启动，并隐藏到托盘中(为减少CPU占用并增加趣味性，设置为开机自动启动，提示网络连接，并输入"go"才执行功能)
  25.         电脑若未关机，则在24:00自动启动，更换背景
  26.  
  27.      ***软件自动更新版本功能
  28.  
  29.  ******************************************************************************************************/
  30.  
  31.  #include <iostream>    //输入输出
  32.  #include <cstring>     //文件命名处理需要用字符串
  33.  #include <windows.h>   //调用操作系统各种API
  34.  #include <ctime>       //获取时间，各种文件命名
  35.  #include <UrlMon.h>    //包含提供下载服务的API
  36.  #include "tinyxml2.h"  //解析XML
  37.  #include <io.h>        //判断文件夹是否存在
  38.  #include <direct.h>    //创建文件夹
  39.  extern "C"
  40.  {
  41.  #include "jpeg.h"    //转换图片格式jpg->bmp  转换格式的程序使用C语言写的
  42.  }
  43.  
  44.  //创建本地bingPicture路径和Tmp路径
  45.  void createDir()
  46.  {
  47.      //本地bingPicture路径
  48.      std::string LocalFolder="C:/bingPicture/";
  49.  
  50.      if(!=access(LocalFolder.c_str(),))    //判断文件夹是否存在，若不存在则创建
  51.          if(!=mkdir(LocalFolder.c_str()))
  52.              std::cout<<"创建文件夹bingPicture失败！"<<std::endl;
  53.          else
  54.              std::cout<<"创建文件夹bingPicture成功！"<<std::endl;
  55.      else
  56.          std::cout<<"文件夹bingPicture已存在！"<<std::endl;
  57.  
  58.      //本地Tmp路径
  59.      std::string LocalXmlFolder="C:/bingPicture/Tmp/";
  60.  
  61.      if(!=access(LocalXmlFolder.c_str(),))    //判断文件夹是否存在，若不存在则创建
  62.          if(!=mkdir(LocalXmlFolder.c_str()))
  63.              std::cout<<"创建临时文件夹Tmp失败！"<<std::endl;
  64.          else
  65.              std::cout<<"创建临时文件夹Tmp成功！"<<std::endl;
  66.      else
  67.          std::cout<<"临时文件夹Tmp已存在！"<<std::endl;
  68.  
  69.  }
  70.  
  71.  /**************************************************************************************
  72.  首先明白一个概念，即string替换所有字符串，将"12212"这个字符串的所有"12"都替换成"21"，结果是什么？
  73.  可以是22211，也可以是21221，有时候应用的场景不同，就会希望得到不同的结果，所以这两种答案都做了实现。
  74.  **************************************************************************************/
  75.  //替换字符串方法1(完全轮询，替换一次后接着再次扫描，因为替换一次后可能又出现了满足替换条件的字符串)
  76.  std::string & replace_all(std::string& str,const std::string& old_value,const std::string& new_value)
  77.  {
  78.      while(true)   {
  79.          std::string::size_type pos();
  80.          if((pos=str.find(old_value))!=std::string::npos)
  81.              str.replace(pos,old_value.length(),new_value);
  82.          else
  83.              break;
  84.      }
  85.      return str;
  86.  }
  87.  
  88.  //替换字符串方法2(只替换一次) 本项目中，只替换\为/用方法2即可
  89.  std::string & replace_all_distinct(std::string& str,const std::string& old_value,const std::string& new_value)
  90.  {
  91.      for(std::string::size_type pos();  pos!=std::string::npos; pos+=new_value.length())
  92.      {
  93.          if((pos=str.find(old_value,pos))!=std::string::npos)
  94.              str.replace(pos,old_value.length(),new_value);
  95.          else   break;
  96.      }
  97.      return str;
  98.  }
  99.  
  100.  //获取年月日(命名用)
  101.  std::string getYearMonthDay()
  102.  {
  103.      time_t timer;
  104.      time(&timer);
  105.      tm* t_tm = localtime(&timer);
  106.  
  107.      std::string Year=std::to_string(t_tm->tm_year+);
  108.      std::string Month=std::to_string(t_tm->tm_mon+);
  109.      std::string Day=std::to_string(t_tm->tm_mday);
  110.      std::string PictureName=Year+"_"+Month+"_"+Day;
  111.  
  112.      return PictureName;
  113.  }
  114.  
  115.  //获取图片的Xml并解析图片的url路径
  116.  std::string getPicTureXmlAndUrl()
  117.  {
  118.      //网络上的XML路径
  119.      std::string WebXmlpath ="http://cn.bing.com/HPImageArchive.aspx?format=xml&idx=0&n=1";
  120.      //本地Xml路径
  121.      std::string LocalXmlFolder="C:/bingPicture/Tmp/";
  122.      std::string LocalXmleach=getYearMonthDay();
  123.      std::string LocalXmlFullpath=LocalXmlFolder+LocalXmleach+".xml";
  124.  
  125.      if(URLDownloadToFileA(NULL,
  126.                           WebXmlpath.c_str(),
  127.                           LocalXmlFullpath.c_str(),
  128.                           ,
  129.                           NULL)
  130.              ==S_OK)
  131.      {
  132.          std::cout<<"Xml下载成功！即将解析今日壁纸Url！"<<std::endl;
  133.  
  134.          /***************下面开始解析xml中的url路径*******************/
  135.          tinyxml2::XMLDocument doc;
  136.          if(tinyxml2::XML_SUCCESS != doc.LoadFile(LocalXmlFullpath.c_str()))
  137.              std::cout<<"读取Xml文件异常！"<<std::endl;
  138.          tinyxml2::XMLElement *images=doc.RootElement();
  139.          tinyxml2::XMLElement *image =images->FirstChildElement("image");
  140.  
  141.          //图片Url
  142.          std::string WebPicturedomain="http://cn.bing.com";
  143.          std::string WebPictureUrl="";
  144.  
  145.          if(image!=NULL)
  146.              WebPictureUrl=image->FirstChildElement("url")->GetText();
  147.  
  148.          std::string WebPictureFullpath1366x768 =WebPicturedomain+WebPictureUrl;
  149.          std::cout<<"今日壁纸Url解析成功!"<<std::endl;
  150.          /*********************************************************/
  151.          return WebPictureFullpath1366x768;
  152.  //        //将1366x768换成1920x1080
  153.  //        std::string WebPictureFullpath1920x1080 =replace_all_distinct(WebPictureFullpath1366x768,"1366x768","1920x1080");
  154.  
  155.  //        return WebPictureFullpath1920x1080;
  156.      }
  157.      else
  158.      {
  159.          std::cout<<"Xml下载失败！无法获取图片Url！请检查网络连接是否正常！"<<std::endl;
  160.          return "error";
  161.      }
  162.  
  163.  }
  164.  
  165.  //从网络上下载图片并存储到本地
  166.  std::string getPicture(std::string WebFullpath)
  167.  {
  168.      //本地存储路径
  169.      std::string LocalFolder="C:/bingPicture/";
  170.      std::string Localeach=getYearMonthDay();
  171.      std::string LocalFullpath=LocalFolder+Localeach+".jpg";
  172.  
  173.      if(URLDownloadToFileA(NULL,
  174.                           WebFullpath.c_str(),
  175.                           LocalFullpath.c_str(),
  176.                           ,
  177.                           NULL)
  178.              ==S_OK)
  179.      {
  180.          std::cout<<"今日壁纸下载成功！"<<std::endl;
  181.  
  182.          /***************下面转换图片格式jpg->bmp******************/
  183.          //临时文件夹Tmp路径
  184.          std::string TmpFolder="C:/bingPicture/Tmp/";
  185.          //.bmp图片路径
  186.          std::string bmpFolder=TmpFolder+getYearMonthDay()+".bmp";
  187.          LoadJpegFile(const_cast<char *>(LocalFullpath.c_str()),const_cast<char *>(bmpFolder.c_str()));
  188.          /*******************************************************/
  189.          return bmpFolder;
  190.      }
  191.      else
  192.      {
  193.          std::cout<<"壁纸下载失败！请检查网络连接是否正常！"<<std::endl;
  194.          return "error";
  195.      }
  196.  }
  197.  
  198.  //改变桌面背景成功后，删除bmp文件和xml文件(只保留jpg文件)，此步骤需要小心，避免删除错误路径下的内容
  199.  void deleteBmpAndXml()
  200.  {
  201.      //临时文件夹Tmp路径
  202.      std::string TmpFolder="C:/bingPicture/Tmp/";
  203.      //.bmp图片路径
  204.      std::string bmpFolder=TmpFolder+getYearMonthDay()+".bmp";
  205.      //xml文件路径
  206.      std::string xmlFolder=TmpFolder+getYearMonthDay()+".xml";
  207.  
  208.      if(==access("C:/bingPicture/Tmp/",))    //判断文件夹是否存在，若存在则删除
  209.      {
  210.          //删除bmp图片
  211.          if(==access(bmpFolder.c_str(),))
  212.          {
  213.              if(==remove(bmpFolder.c_str()))
  214.                  std::cout<<"删除临时bmp格式图片成功！"<<std::endl;
  215.              else
  216.                  std::cout<<"删除临时bmp格式图片失败！"<<std::endl;
  217.          }
  218.          else
  219.              std::cout<<"临时bmp格式图片不存在！"<<std::endl;
  220.  
  221.          //删除xml文件
  222.          if(==access(xmlFolder.c_str(),))
  223.          {
  224.              if(==remove(xmlFolder.c_str()))
  225.                  std::cout<<"删除xml文件成功！"<<std::endl;
  226.              else
  227.                  std::cout<<"删除xml文件失败！"<<std::endl;
  228.          }
  229.          else
  230.              std::cout<<"xml文件不存在！"<<std::endl;
  231.  
  232.          //删除Tmp文件夹(注意此函数只能删除空文件夹,因此要先删除文件夹中的文件)
  233.          if(==rmdir(TmpFolder.c_str()))
  234.              std::cout<<"临时文件夹Tmp已删除！"<<std::endl;
  235.          else
  236.              std::cout<<"临时文件夹Tmp删除失败！"<<std::endl;
  237.      }
  238.      else
  239.          std::cout<<"临时文件夹Tmp不存在！"<<std::endl;
  240.  
  241.  }
  242.  
  243.  //改变桌面背景(PictureFullpath:图片完整路径)
  244.  void changePicture(std::string PictureFullpath)
  245.  {
  246.      bool result=false;
  247.      result=SystemParametersInfoA(SPI_SETDESKWALLPAPER,
  248.                            ,
  249.                            (PVOID)PictureFullpath.c_str(),
  250.                            );
  251.      if(result==false)
  252.      {
  253.          std::cout<<"今日壁纸更新失败！请联系开发人员！"<<std::endl;
  254.      }
  255.  
  256.      else
  257.      {
  258.          SystemParametersInfoA(SPI_SETDESKWALLPAPER,
  259.                                    ,
  260.                                    (PVOID)PictureFullpath.c_str(),
  261.                                    SPIF_SENDCHANGE);
  262.          //deleteBmpAndXml();    //windows8及其以上会变成黑色，把这条语句放到main最后面就没问题，具体原因未知
  263.          system("cls");
  264.          std::cout<<"version:1.0.0 (Author:xiaoxi666)"<<std::endl<<std::endl;
  265.          std::cout<<"今日壁纸更新成功！"<<std::endl<<std::endl;
  266.          std::cout<<"美好的一天开始啦！用心享受吧！"<<std::endl<<std::endl;
  267.      }
  268.  }
  269.  
  270.  int main()
  271.  {
  272.      std::string startOrder="";
  273.      std::cout<<"嗨！小伙伴！你的贴心壁纸小助手已启动！将为你设置今日壁纸哦！"<<std::endl<<std::endl;
  274.      std::cout<<"请确保电脑网络连接状况良好,准备好后输入go"<<std::endl<<std::endl;
  275.      std::cout<<"请输入指令： ";
  276.      std::cin>>startOrder;
  277.      while("go"!=startOrder)
  278.      {
  279.          std::cout<<"哎呀输错了呢,重新输入吧： ";
  280.          std::cin>>startOrder;
  281.      }
  282.      if("go"==startOrder)
  283.      {
  284.          createDir();
  285.          changePicture(getPicture(getPicTureXmlAndUrl()));
  286.      }
  287.  
  288.      /*******************************以下为个性化字幕输出，与程序核心功能无关************************/
  289.      std::string umua0="          **     **   ********   *******   *******   ***  ***     ";
  290.      std::string umua1="          **     **   ********   *******   *******   ***  ***     ";
  291.      std::string umua2="          **     **   **    **   **   **   ***  **   ***  ***     ";
  292.      std::string umua3="          **     **   **    **   **   **   ***  **    **  **      ";
  293.      std::string umua4="          *********   ********   *******   *******     *  *       ";
  294.      std::string umua5="          *********   ********   *******   **           **        ";
  295.      std::string umua6="          **     **   **    **   **        **           **        ";
  296.      std::string umua7="          **     **   **    **   **        **           **        ";
  297.      std::string umua8="          **     **   **    **   **        **           **        ";
  298.      std::string umua9="          **     **   **    **   **        **           **        ";
  299.  
  300.      #define mua(n) std::cout<<umua##n<<std::endl;
  301.      std::cout<<std::endl<<std::endl;
  302.      mua();mua();mua();mua();mua();mua();mua();mua();mua();mua();
  303.      std::cout<<std::endl<<std::endl<<std::endl;
  304.      system("pause");
  305.      /******************************************************************************************/
  306.      deleteBmpAndXml();
  307.      return ;
  308.  }

图片格式转换程序（这个是网上下载的C源码，我改了一下接口，在此感谢）

jpeg.h

  1. //头文件jpeg.h，配合程序jpeg2bmp.c使用
  2. //若用于c++程序中，请用extern "C"包含此头文件
  3. //功能：用于将图片从jpg类型转换为bmp类型,调用函数LoadJpegFile即可，参数1：jpg文件路径；参数2：bmp文件路径
  4.  
  5. #define M_SOF0  0xc0
  6. #define M_DHT   0xc4
  7. #define M_EOI   0xd9
  8. #define M_SOS   0xda
  9. #define M_DQT   0xdb
  10. #define M_DRI   0xdd
  11. #define M_APP0  0xe0
  12.  
  13. static int Zig_Zag[][]={{,,,,,,,},
  14.                           {,,,,,,,},
  15.                           {,,,,,,,},
  16.                           {,,,,,,,},
  17.                           {,,,,,,,},
  18.                           {,,,,,,,},
  19.                           {,,,,,,,},
  20.                           {,,,,,,,}
  21.                          };
  22.  
  23. #define W1 2841 /* 2048*sqrt(2)*cos(1*pi/16) */
  24. #define W2 2676 /* 2048*sqrt(2)*cos(2*pi/16) */
  25. #define W3 2408 /* 2048*sqrt(2)*cos(3*pi/16) */
  26. #define W5 1609 /* 2048*sqrt(2)*cos(5*pi/16) */
  27. #define W6 1108 /* 2048*sqrt(2)*cos(6*pi/16) */
  28. #define W7 565  /* 2048*sqrt(2)*cos(7*pi/16) */
  29.  
  30. int LoadJpegFile (char *JpegFileName,char *bmpFileName);

jpeg2bmp.c

  1. //jpeg.c
  2. //本程序用C语言编写，若用于c++程序中，请用extern "C"包含头文件jpeg.h
  3. //功能：用于将图片从jpg类型转换为bmp类型,调用函数LoadJpegFile即可，参数1：jpg文件路径；参数2：bmp文件路径
  4.  
  5. #include "jpeg.h"
  6. #include "memory.h"
  7. #include "math.h"
  8. #include "stdio.h"
  9. #include "windows.h"
  10.  
  11. //macro definition
  12. #define WIDTHBYTES(i)    ((i+31)/32*4)
  13. #define PI 3.1415926535
  14. //define return value of function
  15. #define FUNC_OK 0
  16. #define FUNC_MEMORY_ERROR 1
  17. #define FUNC_FILE_ERROR 2
  18. #define FUNC_FORMAT_ERROR 3
  19. //////////////////////////////////////////////////
  20. //Jpeg functions
  21. //int LoadJpegFile (char *JpegFileName,char *bmpFileName);
  22. void showerror(int funcret);
  23. int  InitTag();
  24. void InitTable();
  25. int  Decode();
  26. int  DecodeMCUBlock();
  27. int  HufBlock(unsigned char dchufindex,unsigned char achufindex);
  28. int  DecodeElement();
  29. void IQtIZzMCUComponent(short flag);
  30. void IQtIZzBlock(short  *s ,int * d,short flag);
  31. void GetYUV(short flag);
  32. void StoreBuffer();
  33. BYTE ReadByte();
  34. void Initialize_Fast_IDCT();
  35. void Fast_IDCT(int * block);
  36. void idctrow(int * blk);
  37. void idctcol(int * blk);
  38. //////////////////////////////////////////////////
  39. //global variable declaration
  40. BITMAPFILEHEADER   bf;
  41. BITMAPINFOHEADER   bi;
  42. HBITMAP            hBitmap=NULL;
  43. HGLOBAL            hImgData=NULL;
  44. DWORD              NumColors;
  45. DWORD              LineBytes;
  46. DWORD              ImgWidth= , ImgHeight=;
  47. unsigned int       PcxBytesPerLine;
  48. LPSTR              lpPtr;
  49. //////////////////////////////////////////////////
  50. //variables used in jpeg function
  51. short            SampRate_Y_H,SampRate_Y_V;
  52. short            SampRate_U_H,SampRate_U_V;
  53. short            SampRate_V_H,SampRate_V_V;
  54. short            H_YtoU,V_YtoU,H_YtoV,V_YtoV;
  55. short            Y_in_MCU,U_in_MCU,V_in_MCU;
  56. unsigned char   *lpJpegBuf;
  57. unsigned char   *lp;
  58. short            qt_table[][];
  59. short            comp_num;
  60. BYTE            comp_index[];
  61. BYTE            YDcIndex,YAcIndex,UVDcIndex,UVAcIndex;
  62. BYTE            HufTabIndex;
  63. short            *YQtTable,*UQtTable,*VQtTable;
  64. BYTE            And[]={,,,,0xf,0x1f,0x3f,0x7f,0xff};
  65. short            code_pos_table[][],code_len_table[][];
  66. unsigned short    code_value_table[][];
  67. unsigned short    huf_max_value[][],huf_min_value[][];
  68. short            BitPos,CurByte;
  69. short            rrun,vvalue;
  70. short            MCUBuffer[*];
  71. int                QtZzMCUBuffer[*];
  72. short            BlockBuffer[];
  73. short            ycoef,ucoef,vcoef;
  74. BOOL            IntervalFlag;
  75. short            interval=;
  76. int                Y[*],U[*],V[*];
  77. DWORD            sizei,sizej;
  78. short             restart;
  79. static  long    iclip[];
  80. static  long    *iclp;
  81.  
  82. ////////////////////////////////////////////////////////////////
  83. int LoadJpegFile (char *JpegFileName,char *bmpFileName)
  84. {
  85.     HFILE               hfjpg;
  86.     DWORD                ImgSize;
  87.     DWORD              JpegBufSize;
  88.     HFILE              hfbmp;
  89.     HGLOBAL               hJpegBuf;
  90.     int                   funcret;
  91.     LPBITMAPINFOHEADER lpImgData;
  92.  
  93.     if((hfjpg=_lopen(JpegFileName,OF_READ))==HFILE_ERROR)
  94.     {
  95.         showerror(FUNC_FILE_ERROR);
  96.         return ;
  97.     }
  98.     //get jpg file length
  99.     JpegBufSize=_llseek(hfjpg,0L,SEEK_END);
  100.     //rewind to the beginning of the file
  101.     _llseek(hfjpg,0L,SEEK_SET);
  102.  
  103.     if((hJpegBuf=GlobalAlloc(GHND,JpegBufSize))==NULL)
  104.     {
  105.         _lclose(hfjpg);
  106.         showerror(FUNC_MEMORY_ERROR);
  107.         return ;
  108.     }
  109.     lpJpegBuf=(unsigned char  *)GlobalLock(hJpegBuf);
  110.     _hread(hfjpg,(unsigned char  *)lpJpegBuf,JpegBufSize);
  111.     _lclose(hfjpg);
  112.  
  113.     InitTable();
  114.  
  115.     if((funcret=InitTag())!=FUNC_OK)
  116.     {
  117.         GlobalUnlock(hJpegBuf);
  118.         GlobalFree(hJpegBuf);
  119.         showerror(funcret);
  120.         return ;
  121.     }
  122.     //create new bitmapfileheader and bitmapinfoheader
  123.     memset((char *)&bf,,sizeof(BITMAPFILEHEADER));
  124.     memset((char *)&bi,,sizeof(BITMAPINFOHEADER));
  125.  
  126.     bi.biSize=(DWORD)sizeof(BITMAPINFOHEADER);
  127.     bi.biWidth=(LONG)(ImgWidth);
  128.     bi.biHeight=(LONG)(ImgHeight);
  129.     bi.biPlanes=;
  130.     bi.biBitCount=;
  131.     bi.biClrUsed=;
  132.     bi.biClrImportant=;
  133.     bi.biCompression=BI_RGB;
  134.     NumColors=;
  135.     LineBytes=(DWORD)WIDTHBYTES(bi.biWidth*bi.biBitCount);
  136.     ImgSize=(DWORD)LineBytes*bi.biHeight;
  137.  
  138.     bf.bfType=0x4d42;
  139.     bf.bfSize=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+NumColors*sizeof(RGBQUAD)+ImgSize;
  140.     bf.bfOffBits=(DWORD)(NumColors*sizeof(RGBQUAD)+sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER));
  141.  
  142.     if((hImgData=GlobalAlloc(GHND,ImgSize))==NULL)
  143.     {
  144.         GlobalUnlock(hJpegBuf);
  145.         GlobalFree(hJpegBuf);
  146.         showerror(FUNC_MEMORY_ERROR);
  147.         return FALSE;
  148.     }
  149.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);
  150.     lpPtr=(char *)lpImgData;
  151.  
  152.     if((SampRate_Y_H==)||(SampRate_Y_V==))
  153.     {
  154.         GlobalUnlock(hJpegBuf);
  155.         GlobalFree(hJpegBuf);
  156.         GlobalUnlock(hImgData);
  157.         GlobalFree(hImgData);
  158.         hImgData=NULL;
  159.         showerror(FUNC_FORMAT_ERROR);
  160.         return FALSE ;
  161.     }
  162.  
  163.     funcret=Decode();
  164.  
  165.     if(funcret==FUNC_OK)
  166.     {
  167.  
  168.         hfbmp=_lcreat(bmpFileName,);
  169.         _lwrite(hfbmp,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)); //写BMP文件头
  170.         _lwrite(hfbmp,(LPSTR)&bi,sizeof(BITMAPINFOHEADER)); //写BMP文件信息
  171.         _lwrite(hfbmp,(LPSTR)lpImgData,ImgSize);            //写BMP位图数据
  172.         _lclose(hfbmp);
  173.         GlobalUnlock(hJpegBuf);
  174.         GlobalFree(hJpegBuf);
  175.         GlobalUnlock(hImgData);
  176.         return TRUE;
  177.     }
  178.     else
  179.     {
  180.         GlobalUnlock(hJpegBuf);
  181.         GlobalFree(hJpegBuf);
  182.         GlobalUnlock(hImgData);
  183.         GlobalFree(hImgData);
  184.         hImgData=NULL;
  185.         showerror(funcret);
  186.         return FALSE;
  187.     }
  188. }
  189. /////////////////////////////////////////////////
  190. void showerror(int funcret)
  191. {
  192.     switch(funcret)
  193.     {
  194.     case FUNC_MEMORY_ERROR:
  195.         printf("Error alloc memory!\n");
  196.         exit();
  197.         break;
  198.     case FUNC_FILE_ERROR:
  199.         printf("File not found!!\n");
  200.         exit();
  201.         break;
  202.     case FUNC_FORMAT_ERROR:
  203.         printf("File format error!\n");
  204.         exit();
  205.         break;
  206.     }
  207. }
  208. ////////////////////////////////////////////////////////////////////////////////
  209. int InitTag()
  210. {
  211.     BOOL finish=FALSE;
  212.     BYTE id;
  213.     short  llength;
  214.     short  i,j,k;
  215.     short  huftab1,huftab2;
  216.     short  huftabindex;
  217.     BYTE hf_table_index;
  218.     BYTE qt_table_index;
  219.     BYTE comnum;
  220.  
  221.     unsigned char  *lptemp;
  222.     short  ccount;
  223.  
  224.     lp=lpJpegBuf+;
  225.  
  226.     while (!finish)
  227.     {
  228.         id=*(lp+);
  229.         lp+=;
  230.         switch (id)
  231.         {
  232.         case M_APP0:
  233.             llength=MAKEWORD(*(lp+),*lp);
  234.             lp+=llength;
  235.             break;
  236.         case M_DQT:
  237.             llength=MAKEWORD(*(lp+),*lp);
  238.             qt_table_index=(*(lp+))&0x0f;
  239.             lptemp=lp+;
  240.             if(llength<)
  241.             {
  242.                 for(i=;i<;i++)
  243.                     qt_table[qt_table_index][i]=(short)*(lptemp++);
  244.             }
  245.             else
  246.             {
  247.                 for(i=;i<;i++)
  248.                     qt_table[qt_table_index][i]=(short)*(lptemp++);
  249.                 qt_table_index=(*(lptemp++))&0x0f;
  250.                   for(i=;i<;i++)
  251.                     qt_table[qt_table_index][i]=(short)*(lptemp++);
  252.               }
  253.               lp+=llength;
  254.             break;
  255.         case M_SOF0:
  256.              llength=MAKEWORD(*(lp+),*lp);
  257.              ImgHeight=MAKEWORD(*(lp+),*(lp+));
  258.              ImgWidth=MAKEWORD(*(lp+),*(lp+));
  259.             comp_num=*(lp+);
  260.             if((comp_num!=)&&(comp_num!=))
  261.                   return FUNC_FORMAT_ERROR;
  262.             if(comp_num==)
  263.             {
  264.                 comp_index[]=*(lp+);
  265.                   SampRate_Y_H=(*(lp+))>>;
  266.                   SampRate_Y_V=(*(lp+))&0x0f;
  267.                   YQtTable=(short *)qt_table[*(lp+)];
  268.  
  269.                 comp_index[]=*(lp+);
  270.                 SampRate_U_H=(*(lp+))>>;
  271.                   SampRate_U_V=(*(lp+))&0x0f;
  272.                   UQtTable=(short *)qt_table[*(lp+)];
  273.  
  274.                   comp_index[]=*(lp+);
  275.                   SampRate_V_H=(*(lp+))>>;
  276.                   SampRate_V_V=(*(lp+))&0x0f;
  277.                 VQtTable=(short *)qt_table[*(lp+)];
  278.               }
  279.             else
  280.             {
  281.                   comp_index[]=*(lp+);
  282.                 SampRate_Y_H=(*(lp+))>>;
  283.                   SampRate_Y_V=(*(lp+))&0x0f;
  284.                   YQtTable=(short *)qt_table[*(lp+)];
  285.  
  286.                 comp_index[]=*(lp+);
  287.                   SampRate_U_H=;
  288.                   SampRate_U_V=;
  289.                   UQtTable=(short *)qt_table[*(lp+)];
  290.  
  291.                 comp_index[]=*(lp+);
  292.                 SampRate_V_H=;
  293.                   SampRate_V_V=;
  294.                   VQtTable=(short *)qt_table[*(lp+)];
  295.             }
  296.               lp+=llength;
  297.             break;
  298.         case M_DHT:
  299.             llength=MAKEWORD(*(lp+),*lp);
  300.             if (llength<0xd0)
  301.             {
  302.                 huftab1=(short)(*(lp+))>>;     //huftab1=0,1
  303.                  huftab2=(short)(*(lp+))&0x0f;   //huftab2=0,1
  304.                 huftabindex=huftab1*+huftab2;
  305.                  lptemp=lp+;
  306.                 for (i=; i<; i++)
  307.                     code_len_table[huftabindex][i]=(short)(*(lptemp++));
  308.                 j=;
  309.                 for (i=; i<; i++)
  310.                     if(code_len_table[huftabindex][i]!=)
  311.                     {
  312.                         k=;
  313.                         while(k<code_len_table[huftabindex][i])
  314.                         {
  315.                             code_value_table[huftabindex][k+j]=(short)(*(lptemp++));
  316.                             k++;
  317.                         }
  318.                         j+=k;
  319.                     }
  320.                 i=;
  321.                 while (code_len_table[huftabindex][i]==)
  322.                      i++;
  323.                 for (j=;j<i;j++)
  324.                 {
  325.                     huf_min_value[huftabindex][j]=;
  326.                     huf_max_value[huftabindex][j]=;
  327.                 }
  328.                 huf_min_value[huftabindex][i]=;
  329.                 huf_max_value[huftabindex][i]=code_len_table[huftabindex][i]-;
  330.                 for (j=i+;j<;j++)
  331.                 {
  332.                     huf_min_value[huftabindex][j]=(huf_max_value[huftabindex][j-]+)<<;
  333.                     huf_max_value[huftabindex][j]=huf_min_value[huftabindex][j]+code_len_table[huftabindex][j]-;
  334.                 }
  335.                 code_pos_table[huftabindex][]=;
  336.                 for (j=;j<;j++)
  337.                       code_pos_table[huftabindex][j]=code_len_table[huftabindex][j-]+code_pos_table[huftabindex][j-];
  338.                   lp+=llength;
  339.             }  //if
  340.             else
  341.             {
  342.                  hf_table_index=*(lp+);
  343.                 lp+=;
  344.                 while (hf_table_index!=0xff)
  345.                 {
  346.                     huftab1=(short)hf_table_index>>;     //huftab1=0,1
  347.                      huftab2=(short)hf_table_index&0x0f;   //huftab2=0,1
  348.                     huftabindex=huftab1*+huftab2;
  349.                     lptemp=lp+;
  350.                     ccount=;
  351.                     for (i=; i<; i++)
  352.                     {
  353.                         code_len_table[huftabindex][i]=(short)(*(lptemp++));
  354.                         ccount+=code_len_table[huftabindex][i];
  355.                     }
  356.                     ccount+=;
  357.                     j=;
  358.                     for (i=; i<; i++)
  359.                         if(code_len_table[huftabindex][i]!=)
  360.                         {
  361.                             k=;
  362.                             while(k<code_len_table[huftabindex][i])
  363.                             {
  364.                                 code_value_table[huftabindex][k+j]=(short)(*(lptemp++));
  365.                                 k++;
  366.                             }
  367.                             j+=k;
  368.                         }
  369.                     i=;
  370.                     while (code_len_table[huftabindex][i]==)
  371.                         i++;
  372.                     for (j=;j<i;j++)
  373.                     {
  374.                         huf_min_value[huftabindex][j]=;
  375.                         huf_max_value[huftabindex][j]=;
  376.                     }
  377.                     huf_min_value[huftabindex][i]=;
  378.                     huf_max_value[huftabindex][i]=code_len_table[huftabindex][i]-;
  379.                     for (j=i+;j<;j++)
  380.                     {
  381.                         huf_min_value[huftabindex][j]=(huf_max_value[huftabindex][j-]+)<<;
  382.                         huf_max_value[huftabindex][j]=huf_min_value[huftabindex][j]+code_len_table[huftabindex][j]-;
  383.                     }
  384.                     code_pos_table[huftabindex][]=;
  385.                     for (j=;j<;j++)
  386.                         code_pos_table[huftabindex][j]=code_len_table[huftabindex][j-]+code_pos_table[huftabindex][j-];
  387.                     lp+=ccount;
  388.                     hf_table_index=*lp;
  389.                 }  //while
  390.             }  //else
  391.             break;
  392.         case M_DRI:
  393.             llength=MAKEWORD(*(lp+),*lp);
  394.             restart=MAKEWORD(*(lp+),*(lp+));
  395.             lp+=llength;
  396.             break;
  397.         case M_SOS:
  398.             llength=MAKEWORD(*(lp+),*lp);
  399.             comnum=*(lp+);
  400.             if(comnum!=comp_num)
  401.                 return FUNC_FORMAT_ERROR;
  402.             lptemp=lp+;
  403.             for (i=;i<comp_num;i++)
  404.             {
  405.                 if(*lptemp==comp_index[])
  406.                 {
  407.                     YDcIndex=(*(lptemp+))>>;   //Y
  408.                     YAcIndex=((*(lptemp+))&0x0f)+;
  409.                 }
  410.                 else{
  411.                     UVDcIndex=(*(lptemp+))>>;   //U,V
  412.                     UVAcIndex=((*(lptemp+))&0x0f)+;
  413.                 }
  414.                 lptemp+=;
  415.             }
  416.             lp+=llength;
  417.             finish=TRUE;
  418.             break;
  419.         case M_EOI:
  420.             return FUNC_FORMAT_ERROR;
  421.             break;
  422.         default:
  423.              if ((id&0xf0)!=0xd0)
  424.             {
  425.                 llength=MAKEWORD(*(lp+),*lp);
  426.                  lp+=llength;
  427.             }
  428.             else lp+=;
  429.             break;
  430.           }  //switch
  431.     } //while
  432.     return FUNC_OK;
  433. }
  434. /////////////////////////////////////////////////////////////////
  435. void InitTable()
  436. {
  437.     short i,j;
  438.     sizei=sizej=;
  439.     ImgWidth=ImgHeight=;
  440.     rrun=vvalue=;
  441.     BitPos=;
  442.     CurByte=;
  443.     IntervalFlag=FALSE;
  444.     restart=;
  445.     for(i=;i<;i++)
  446.         for(j=;j<;j++)
  447.             qt_table[i][j]=;
  448.     comp_num=;
  449.     HufTabIndex=;
  450.     for(i=;i<;i++)
  451.         comp_index[i]=;
  452.     for(i=;i<;i++)
  453.         for(j=;j<;j++)
  454.         {
  455.             code_len_table[i][j]=;
  456.             code_pos_table[i][j]=;
  457.             huf_max_value[i][j]=;
  458.             huf_min_value[i][j]=;
  459.         }
  460.     for(i=;i<;i++)
  461.         for(j=;j<;j++)
  462.             code_value_table[i][j]=;
  463.  
  464.     for(i=;i<*;i++)
  465.     {
  466.         MCUBuffer[i]=;
  467.         QtZzMCUBuffer[i]=;
  468.     }
  469.     for(i=;i<*;i++)
  470.     {
  471.         Y[i]=;
  472.         U[i]=;
  473.         V[i]=;
  474.     }
  475.     for(i=;i<;i++)
  476.         BlockBuffer[i]=;
  477.     ycoef=ucoef=vcoef=;
  478. }
  479. /////////////////////////////////////////////////////////////////////////
  480. int Decode()
  481. {
  482.     int funcret;
  483.  
  484.     Y_in_MCU=SampRate_Y_H*SampRate_Y_V;
  485.     U_in_MCU=SampRate_U_H*SampRate_U_V;
  486.     V_in_MCU=SampRate_V_H*SampRate_V_V;
  487.     H_YtoU=SampRate_Y_H/SampRate_U_H;
  488.     V_YtoU=SampRate_Y_V/SampRate_U_V;
  489.     H_YtoV=SampRate_Y_H/SampRate_V_H;
  490.     V_YtoV=SampRate_Y_V/SampRate_V_V;
  491.     Initialize_Fast_IDCT();
  492.     while((funcret=DecodeMCUBlock())==FUNC_OK)
  493.     {
  494.         interval++;
  495.         if((restart)&&(interval % restart==))
  496.              IntervalFlag=TRUE;
  497.         else
  498.             IntervalFlag=FALSE;
  499.         IQtIZzMCUComponent();
  500.         IQtIZzMCUComponent();
  501.         IQtIZzMCUComponent();
  502.         GetYUV();
  503.         GetYUV();
  504.         GetYUV();
  505.         StoreBuffer();
  506.         sizej+=SampRate_Y_H*;
  507.         if(sizej>=ImgWidth)
  508.         {
  509.             sizej=;
  510.             sizei+=SampRate_Y_V*;
  511.         }
  512.         if ((sizej==)&&(sizei>=ImgHeight))
  513.             break;
  514.     }
  515.     return funcret;
  516. }
  517. /////////////////////////////////////////////////////////////////////////////////////////
  518. void  GetYUV(short flag)
  519. {
  520.     short    H,VV;
  521.     short    i,j,k,h;
  522.     int        *buf;
  523.     int        *pQtZzMCU;
  524.  
  525.     switch(flag)
  526.     {
  527.     case :
  528.         H=SampRate_Y_H;
  529.         VV=SampRate_Y_V;
  530.         buf=Y;
  531.         pQtZzMCU=QtZzMCUBuffer;
  532.         break;
  533.     case :
  534.         H=SampRate_U_H;
  535.         VV=SampRate_U_V;
  536.         buf=U;
  537.         pQtZzMCU=QtZzMCUBuffer+Y_in_MCU*;
  538.         break;
  539.     case :
  540.         H=SampRate_V_H;
  541.         VV=SampRate_V_V;
  542.         buf=V;
  543.         pQtZzMCU=QtZzMCUBuffer+(Y_in_MCU+U_in_MCU)*;
  544.         break;
  545.     }
  546.     for (i=;i<VV;i++)
  547.         for(j=;j<H;j++)
  548.             for(k=;k<;k++)
  549.                 for(h=;h<;h++)
  550.                     buf[(i*+k)*SampRate_Y_H*+j*+h]=*pQtZzMCU++;
  551. }
  552. ///////////////////////////////////////////////////////////////////////////////
  553. void StoreBuffer()
  554. {
  555.     short i,j;
  556.     unsigned char  *lpbmp;
  557.     unsigned char R,G,B;
  558.     int y,u,v,rr,gg,bb;
  559.  
  560.     for(i=;i<SampRate_Y_V*;i++)
  561.     {
  562.         if((sizei+i)<ImgHeight)
  563.         {
  564.             lpbmp=((unsigned char *)lpPtr+(DWORD)(ImgHeight-sizei-i-)*LineBytes+sizej*);
  565.             for(j=;j<SampRate_Y_H*;j++)
  566.             {
  567.                 if((sizej+j)<ImgWidth)
  568.                 {
  569.                     y=Y[i**SampRate_Y_H+j];
  570.                     u=U[(i/V_YtoU)**SampRate_Y_H+j/H_YtoU];
  571.                     v=V[(i/V_YtoV)**SampRate_Y_H+j/H_YtoV];
  572.                     rr=((y<<)+*u+*v)>>;
  573.                     gg=((y<<)-*u-*v)>>;
  574.                     bb=((y<<)+*u-*v)>>;
  575.                     R=(unsigned char)rr;
  576.                     G=(unsigned char)gg;
  577.                     B=(unsigned char)bb;
  578.                     if (rr&0xffffff00) if (rr>) R=; else if (rr<) R=;
  579.                     if (gg&0xffffff00) if (gg>) G=; else if (gg<) G=;
  580.                     if (bb&0xffffff00) if (bb>) B=; else if (bb<) B=;
  581.                     *lpbmp++=B;
  582.                     *lpbmp++=G;
  583.                     *lpbmp++=R;
  584.                 }
  585.                 else  break;
  586.             }
  587.         }
  588.         else break;
  589.     }
  590. }
  591. ///////////////////////////////////////////////////////////////////////////////
  592. int DecodeMCUBlock()
  593. {
  594.     short *lpMCUBuffer;
  595.     short i,j;
  596.     int funcret;
  597.  
  598.     if (IntervalFlag)
  599.     {
  600.         lp+=;
  601.         ycoef=ucoef=vcoef=;
  602.         BitPos=;
  603.         CurByte=;
  604.     }
  605.     switch(comp_num)
  606.     {
  607.     case :
  608.         lpMCUBuffer=MCUBuffer;
  609.         for (i=;i<SampRate_Y_H*SampRate_Y_V;i++)  //Y
  610.         {
  611.             funcret=HufBlock(YDcIndex,YAcIndex);
  612.             if (funcret!=FUNC_OK)
  613.                 return funcret;
  614.             BlockBuffer[]=BlockBuffer[]+ycoef;
  615.             ycoef=BlockBuffer[];
  616.             for (j=;j<;j++)
  617.                 *lpMCUBuffer++=BlockBuffer[j];
  618.         }
  619.         for (i=;i<SampRate_U_H*SampRate_U_V;i++)  //U
  620.         {
  621.             funcret=HufBlock(UVDcIndex,UVAcIndex);
  622.             if (funcret!=FUNC_OK)
  623.                 return funcret;
  624.             BlockBuffer[]=BlockBuffer[]+ucoef;
  625.             ucoef=BlockBuffer[];
  626.             for (j=;j<;j++)
  627.                 *lpMCUBuffer++=BlockBuffer[j];
  628.         }
  629.         for (i=;i<SampRate_V_H*SampRate_V_V;i++)  //V
  630.         {
  631.             funcret=HufBlock(UVDcIndex,UVAcIndex);
  632.             if (funcret!=FUNC_OK)
  633.                 return funcret;
  634.             BlockBuffer[]=BlockBuffer[]+vcoef;
  635.             vcoef=BlockBuffer[];
  636.             for (j=;j<;j++)
  637.                 *lpMCUBuffer++=BlockBuffer[j];
  638.         }
  639.         break;
  640.     case :
  641.         lpMCUBuffer=MCUBuffer;
  642.         funcret=HufBlock(YDcIndex,YAcIndex);
  643.         if (funcret!=FUNC_OK)
  644.             return funcret;
  645.         BlockBuffer[]=BlockBuffer[]+ycoef;
  646.         ycoef=BlockBuffer[];
  647.         for (j=;j<;j++)
  648.             *lpMCUBuffer++=BlockBuffer[j];
  649.         for (i=;i<;i++)
  650.             *lpMCUBuffer++=;
  651.         break;
  652.     default:
  653.         return FUNC_FORMAT_ERROR;
  654.     }
  655.     return FUNC_OK;
  656. }
  657. //////////////////////////////////////////////////////////////////
  658. int HufBlock(BYTE dchufindex,BYTE achufindex)
  659. {
  660.     short count=;
  661.     short i;
  662.     int funcret;
  663.  
  664.     //dc
  665.     HufTabIndex=dchufindex;
  666.     funcret=DecodeElement();
  667.     if(funcret!=FUNC_OK)
  668.         return funcret;
  669.  
  670.     BlockBuffer[count++]=vvalue;
  671.     //ac
  672.     HufTabIndex=achufindex;
  673.     while (count<)
  674.     {
  675.         funcret=DecodeElement();
  676.         if(funcret!=FUNC_OK)
  677.             return funcret;
  678.         if ((rrun==)&&(vvalue==))
  679.         {
  680.             for (i=count;i<;i++)
  681.                 BlockBuffer[i]=;
  682.             count=;
  683.         }
  684.         else
  685.         {
  686.             for (i=;i<rrun;i++)
  687.                 BlockBuffer[count++]=;
  688.             BlockBuffer[count++]=vvalue;
  689.         }
  690.     }
  691.     return FUNC_OK;
  692. }
  693. //////////////////////////////////////////////////////////////////////////////
  694. int DecodeElement()
  695. {
  696.     int thiscode,tempcode;
  697.     unsigned short temp,valueex;
  698.     short codelen;
  699.     BYTE hufexbyte,runsize,tempsize,sign;
  700.     BYTE newbyte,lastbyte;
  701.  
  702.     if(BitPos>=)
  703.     {
  704.         BitPos--;
  705.         thiscode=(BYTE)CurByte>>BitPos;
  706.         CurByte=CurByte&And[BitPos];
  707.     }
  708.     else
  709.     {
  710.         lastbyte=ReadByte();
  711.         BitPos--;
  712.         newbyte=CurByte&And[BitPos];
  713.         thiscode=lastbyte>>;
  714.         CurByte=newbyte;
  715.     }
  716.     codelen=;
  717.     while ((thiscode<huf_min_value[HufTabIndex][codelen-])||
  718.           (code_len_table[HufTabIndex][codelen-]==)||
  719.           (thiscode>huf_max_value[HufTabIndex][codelen-]))
  720.     {
  721.         if(BitPos>=)
  722.         {
  723.             BitPos--;
  724.             tempcode=(BYTE)CurByte>>BitPos;
  725.             CurByte=CurByte&And[BitPos];
  726.         }
  727.         else
  728.         {
  729.             lastbyte=ReadByte();
  730.             BitPos--;
  731.             newbyte=CurByte&And[BitPos];
  732.             tempcode=(BYTE)lastbyte>>;
  733.             CurByte=newbyte;
  734.         }
  735.         thiscode=(thiscode<<)+tempcode;
  736.         codelen++;
  737.         if(codelen>)
  738.             return FUNC_FORMAT_ERROR;
  739.     }  //while
  740.     temp=thiscode-huf_min_value[HufTabIndex][codelen-]+code_pos_table[HufTabIndex][codelen-];
  741.     hufexbyte=(BYTE)code_value_table[HufTabIndex][temp];
  742.     rrun=(short)(hufexbyte>>);
  743.     runsize=hufexbyte&0x0f;
  744.     if(runsize==)
  745.     {
  746.         vvalue=;
  747.         return FUNC_OK;
  748.     }
  749.     tempsize=runsize;
  750.     if(BitPos>=runsize)
  751.     {
  752.         BitPos-=runsize;
  753.         valueex=(BYTE)CurByte>>BitPos;
  754.         CurByte=CurByte&And[BitPos];
  755.     }
  756.     else
  757.     {
  758.         valueex=CurByte;
  759.         tempsize-=BitPos;
  760.         while(tempsize>)
  761.         {
  762.             lastbyte=ReadByte();
  763.             valueex=(valueex<<)+(BYTE)lastbyte;
  764.             tempsize-=;
  765.         }  //while
  766.         lastbyte=ReadByte();
  767.         BitPos-=tempsize;
  768.         valueex=(valueex<<tempsize)+(lastbyte>>BitPos);
  769.         CurByte=lastbyte&And[BitPos];
  770.     }  //else
  771.     sign=valueex>>(runsize-);
  772.     if(sign)
  773.         vvalue=valueex;
  774.     else
  775.     {
  776.         valueex=valueex^0xffff;
  777.         temp=0xffff<<runsize;
  778.         vvalue=-(short)(valueex^temp);
  779.     }
  780.     return FUNC_OK;
  781. }
  782. /////////////////////////////////////////////////////////////////////////////////////
  783. void IQtIZzMCUComponent(short flag)
  784. {
  785.     short H,VV;
  786.     short i,j;
  787.     int *pQtZzMCUBuffer;
  788.     short  *pMCUBuffer;
  789.  
  790.     switch(flag)
  791.     {
  792.     case :
  793.         H=SampRate_Y_H;
  794.         VV=SampRate_Y_V;
  795.         pMCUBuffer=MCUBuffer;
  796.         pQtZzMCUBuffer=QtZzMCUBuffer;
  797.         break;
  798.     case :
  799.         H=SampRate_U_H;
  800.         VV=SampRate_U_V;
  801.         pMCUBuffer=MCUBuffer+Y_in_MCU*;
  802.         pQtZzMCUBuffer=QtZzMCUBuffer+Y_in_MCU*;
  803.         break;
  804.     case :
  805.         H=SampRate_V_H;
  806.         VV=SampRate_V_V;
  807.         pMCUBuffer=MCUBuffer+(Y_in_MCU+U_in_MCU)*;
  808.         pQtZzMCUBuffer=QtZzMCUBuffer+(Y_in_MCU+U_in_MCU)*;
  809.         break;
  810.     }
  811.     for(i=;i<VV;i++)
  812.         for (j=;j<H;j++)
  813.             IQtIZzBlock(pMCUBuffer+(i*H+j)*,pQtZzMCUBuffer+(i*H+j)*,flag);
  814. }
  815. //////////////////////////////////////////////////////////////////////////////////////////
  816. void IQtIZzBlock(short  *s ,int * d,short flag)
  817. {
  818.     short i,j;
  819.     short tag;
  820.     short *pQt;
  821.     int buffer2[][];
  822.     int *buffer1;
  823.     short offset;
  824.  
  825.     switch(flag)
  826.     {
  827.     case :
  828.         pQt=YQtTable;
  829.         offset=;
  830.         break;
  831.     case :
  832.         pQt=UQtTable;
  833.         offset=;
  834.         break;
  835.     case :
  836.         pQt=VQtTable;
  837.         offset=;
  838.         break;
  839.     }
  840.  
  841.     for(i=;i<;i++)
  842.         for(j=;j<;j++)
  843.         {
  844.             tag=Zig_Zag[i][j];
  845.             buffer2[i][j]=(int)s[tag]*(int)pQt[tag];
  846.         }
  847.     buffer1=(int *)buffer2;
  848.     Fast_IDCT(buffer1);
  849.     for(i=;i<;i++)
  850.         for(j=;j<;j++)
  851.             d[i*+j]=buffer2[i][j]+offset;
  852. }
  853. ///////////////////////////////////////////////////////////////////////////////
  854. void Fast_IDCT(int * block)
  855. {
  856.     short i;
  857.  
  858.     for (i=; i<; i++)
  859.         idctrow(block+*i);
  860.  
  861.     for (i=; i<; i++)
  862.         idctcol(block+i);
  863. }
  864. ///////////////////////////////////////////////////////////////////////////////
  865. BYTE  ReadByte()
  866. {
  867.     BYTE  i;
  868.  
  869.     i=*(lp++);
  870.     if(i==0xff)
  871.         lp++;
  872.     BitPos=;
  873.     CurByte=i;
  874.     return i;
  875. }
  876. ///////////////////////////////////////////////////////////////////////
  877. void Initialize_Fast_IDCT()
  878. {
  879.     short i;
  880.  
  881.     iclp = iclip+;
  882.     for (i= -; i<; i++)
  883.         iclp[i] = (i<-) ? - : ((i>) ?  : i);
  884. }
  885. ////////////////////////////////////////////////////////////////////////
  886. void idctrow(int * blk)
  887. {
  888.     int x0, x1, x2, x3, x4, x5, x6, x7, x8;
  889.     //intcut
  890.     if (!((x1 = blk[]<<) | (x2 = blk[]) | (x3 = blk[]) |
  891.         (x4 = blk[]) | (x5 = blk[]) | (x6 = blk[]) | (x7 = blk[])))
  892.     {
  893.         blk[]=blk[]=blk[]=blk[]=blk[]=blk[]=blk[]=blk[]=blk[]<<;
  894.         return;
  895.     }
  896.     x0 = (blk[]<<) + ; // for proper rounding in the fourth stage
  897.     //first stage
  898.     x8 = W7*(x4+x5);
  899.     x4 = x8 + (W1-W7)*x4;
  900.     x5 = x8 - (W1+W7)*x5;
  901.     x8 = W3*(x6+x7);
  902.     x6 = x8 - (W3-W5)*x6;
  903.     x7 = x8 - (W3+W5)*x7;
  904.     //second stage
  905.     x8 = x0 + x1;
  906.     x0 -= x1;
  907.     x1 = W6*(x3+x2);
  908.     x2 = x1 - (W2+W6)*x2;
  909.     x3 = x1 + (W2-W6)*x3;
  910.     x1 = x4 + x6;
  911.     x4 -= x6;
  912.     x6 = x5 + x7;
  913.     x5 -= x7;
  914.     //third stage
  915.     x7 = x8 + x3;
  916.     x8 -= x3;
  917.     x3 = x0 + x2;
  918.     x0 -= x2;
  919.     x2 = (*(x4+x5)+)>>;
  920.     x4 = (*(x4-x5)+)>>;
  921.     //fourth stage
  922.     blk[] = (x7+x1)>>;
  923.     blk[] = (x3+x2)>>;
  924.     blk[] = (x0+x4)>>;
  925.     blk[] = (x8+x6)>>;
  926.     blk[] = (x8-x6)>>;
  927.     blk[] = (x0-x4)>>;
  928.     blk[] = (x3-x2)>>;
  929.     blk[] = (x7-x1)>>;
  930. }
  931. //////////////////////////////////////////////////////////////////////////////
  932. void idctcol(int * blk)
  933. {
  934.     int x0, x1, x2, x3, x4, x5, x6, x7, x8;
  935.     //intcut
  936.     if (!((x1 = (blk[*]<<)) | (x2 = blk[*]) | (x3 = blk[*]) |
  937.         (x4 = blk[*]) | (x5 = blk[*]) | (x6 = blk[*]) | (x7 = blk[*])))
  938.     {
  939.         blk[*]=blk[*]=blk[*]=blk[*]=blk[*]=blk[*]
  940.             =blk[*]=blk[*]=iclp[(blk[*]+)>>];
  941.         return;
  942.     }
  943.     x0 = (blk[*]<<) + ;
  944.     //first stage
  945.     x8 = W7*(x4+x5) + ;
  946.     x4 = (x8+(W1-W7)*x4)>>;
  947.     x5 = (x8-(W1+W7)*x5)>>;
  948.     x8 = W3*(x6+x7) + ;
  949.     x6 = (x8-(W3-W5)*x6)>>;
  950.     x7 = (x8-(W3+W5)*x7)>>;
  951.     //second stage
  952.     x8 = x0 + x1;
  953.     x0 -= x1;
  954.     x1 = W6*(x3+x2) + ;
  955.     x2 = (x1-(W2+W6)*x2)>>;
  956.     x3 = (x1+(W2-W6)*x3)>>;
  957.     x1 = x4 + x6;
  958.     x4 -= x6;
  959.     x6 = x5 + x7;
  960.     x5 -= x7;
  961.     //third stage
  962.     x7 = x8 + x3;
  963.     x8 -= x3;
  964.     x3 = x0 + x2;
  965.     x0 -= x2;
  966.     x2 = (*(x4+x5)+)>>;
  967.     x4 = (*(x4-x5)+)>>;
  968.     //fourth stage
  969.     blk[*] = iclp[(x7+x1)>>];
  970.     blk[*] = iclp[(x3+x2)>>];
  971.     blk[*] = iclp[(x0+x4)>>];
  972.     blk[*] = iclp[(x8+x6)>>];
  973.     blk[*] = iclp[(x8-x6)>>];
  974.     blk[*] = iclp[(x0-x4)>>];
  975.     blk[*] = iclp[(x3-x2)>>];
  976.     blk[*] = iclp[(x7-x1)>>];
  977. }
  978.  
  979. //main(   )
  980. //{
  981. //        LoadJpegFile("test.jpg");
  982. //}

xml解析，我用的是TinyXml2开源库，这个就不贴源码了。

关于Qt项目图标制作

我用的Qt版本是4.8.5。

步骤如下：

  1. 在Qt工程目录下新建一个文本文件，并将其名称改为 *.rc （名字任取）
  2. 将你的图标文件.ico添加到项目中

  3. 打开该 rc 文件，在该rc文件里面加入以下一行文本（将文本中的*换成你的图标的名字）：

    IDI_ICON   ICON    DISCARDABLE     "*.ico"
  4. 在项目文件.pro中加入以下文本（将*换成你的rc文件名字）：

　　　　　RC_FILE = \
   　　　　　　　　  *.rc

5. 重新编译工程即可

　　　

关于Qt项目的发布

Qt项目发布最麻烦的就是动态依赖库，常用的工具是hap-depends，它可以查看软件的依赖库(*.dll)，直接用它打开你的.exe文件，查看缺失哪些.dll文件，找到它们后和exe放在相同目录即可。

当然，发布之前需要经过多个平台的测试。

最后祝大家生活愉快！

获取bing图片并自动设置为电脑桌面背景（C++完整开源程序）的更多相关文章

  1. 【开源程序（C++）】获取bing图片并自动设置为电脑桌面背景

    众所周知,bing搜索网站首页每日会更新一张图片,张张漂亮(额,也有一些不合我口味的),特别适合用来做电脑壁纸. 我们想要将bing网站背景图片设置为电脑桌面背景的通常做法是: 上网,搜索bing 找 ...

  2. 获取bing图片并自动设置为电脑桌面背景（使用 URLDownloadToFile API函数）

    众所周知,bing搜索网站首页每日会更新一张图片,张张漂亮(额,也有一些不合我口味的),特别适合用来做电脑壁纸. 我们想要将bing网站背景图片设置为电脑桌面背景的通常做法是: 上网,搜索bing 找 ...

  3. UGUI之导入图片之前自动设置图片打包的 tag

    之前一直在用的是NGUI,最近不知怎么突然兴趣来潮,想学习一下UGUI,毕竟,现在纵观Unity的市场,完全是UGUI的天下,NGUI已经渐渐退隐江湖,哈哈哈... 先来记录下,在图片资源导入到Uni ...

  4. Wince 6.0获取设备的分辨率 自动设置窗体位置

    调用微软提供给wince的API  “coredll.dll” [DllImport("coredll.dll")] public static extern int GetSys ...

  5. Unity3D 导入贴图、模型等资源文件时自动设置参数

    脚本继承至AssetPostprocessor, 存放在Editor目录下! using UnityEngine; using System.Collections; using UnityEdito ...

  6. 使用CSS设置边框和背景

    一.设置边框 1.边框样式 属性 说明 border-width 设置边框的宽度 boder-style 设置边框的样式 border-color 设置边框的颜色 a.border-width属性 自 ...

  7. 获取bing.com的图片并在gnome3中设置自动切换

    发现 bing.com 上的图片很好看,因此打算每天把 bing.com 的图片下载下来,用作桌面. 需要做的是两个部分,爬取图片到目录和设置目录图片为桌面背景并可以自动切换. 第一部分,下载图片,使 ...

  8. 获取Bing每日图片API接口

    bing图片每日更新,对于这一点感觉挺不错的,如果能够把bing每日图片作为博客背景是不是很不错呢?首先我们进入Bing首页,会发现自动转到中国版.不过这没关系,中国版更符合国情,速度也比国际版快一些 ...

  9. HTML-制作图片的自动播放和手动切换

    思路:将想要播放的图片放入集合中,设置一个div,将图片依次从集合中定时取出放到div中展示:设置一个变量,通过变量与集合元素索引联系起来,点击改变时,获取当前图片的索引以切换图片 整体代码: < ...

随机推荐

  1. 如何将lrc歌词文件批量转换为ANSI编码？

    有些MP3.MP4或学习机只能播放ANSI编码的歌词文件,可是从网站上下载的歌词大多是UTF-8或者其它机器支持不了的编码,如何批量将这些lrc歌词文件转换成ANSI编码的文件呢? 工具/原料 萍客T ...

  2. Flex4 flash builder保留MXML转换的AS代码

    Flex4 flash builder保留MXML转换的AS代码 项目->属性->Flex编译器 | 附加的编译参数 加上 -keep 生成的Test005-interface.as文件: ...

  3. #最小生成树# #kruskal# ----- OpenJudge丛林中的路

    最小生成树 一个有 n 个结点的连通图的生成树是原图的极小连通子图,且包含原图中的所有 n 个结点,并且有保持图连通的最少的边.最小生成树可以用kruskal(克鲁斯卡尔)算法或prim(普里姆)算法 ...

  4. Flex组件的生命周期

    组件实例化生命周期描述了用组件类创建组件对象时所发生的一系列步骤,作为生命周期的一部分,flex自动调用组件的的方法,发出事件,并使组件可见. 下面例子用as创建一个btn控件,并将其加入容器中 va ...

  5. MyBatis:学习笔记(3)——关联查询

    MyBatis:学习笔记(3)--关联查询 关联查询 理解联结 SQL最强大的功能之一在于我们可以在数据查询的执行中可以使用联结,来将多个表中的数据作为整体进行筛选. 模拟一个简单的在线商品购物系统, ...

  6. MVC 5 on Windows Server 2008/IIS 7

    将网站部署在2008上,结果出现了 HTTP Error 403.14 - Forbidden The Web server is configured to not list the content ...

  7. 一个可以提高开发效率的Git命令-- Cherry-Pick

    在实际的项目开发中(使用Git版本控制),在所难免会遇到没有切换分支开发.需要在另一个分支修改bug然后合并到当前分支的情况.之前遇到这种第一反应就是将分支合并过去来解决问题.如果你那些提交当中也穿插 ...

  8. node Express安装与使用(一)

    首先放上官网地址 http://www.expressjs.com.cn/ 学会查阅官方手册,它是最好的资料. 1.Express安装 首先确定你已经安装了 Node.js,然后去你创建的项目目录下( ...

  9. 【2(2N+1)魔方阵 】

    /* 2(2N+1)魔方阵 */ #include<stdio.h> #include<stdlib.h> #define N 6 #define SWAP(x, y) {in ...

  10. Xamarin开发IOS系列教程一：安装黑苹果

    经过一番思想挣扎和斗争之后,最终还是选择采用Xamarin来开发跨平台移动应用,好处和优点大家可以搜索其它博文,因为家里面穷加上谈了恋爱,就不买苹果了,开发阶段在Windows上面直接搞定哈,时候不早 ...