static void ResizeImage(string SourceFile, string DestinationFile, ImageCodecInfo encoder, EncoderParameters parameters)
 {
     try
     {
         using (Image Source = Image.FromFile(SourceFile))
         {
             int NewWidth, NewHeight;
             if (Source.Width > ResizeMaxPixels && Source.Width >= Source.Height)
             {
                 NewWidth = ResizeMaxPixels;
                 NewHeight = (Source.Height * ResizeMaxPixels) / Source.Width;
                 using (Image Dest = ResizeImage(Source, NewWidth, NewHeight))
                     Dest.Save(DestinationFile, encoder, parameters);
             }
             else if (Source.Height > ResizeMaxPixels && Source.Height >= Source.Width)
             {
                 NewWidth = (Source.Width * ResizeMaxPixels) / Source.Height;
                 NewHeight = ResizeMaxPixels;
                 using (Image Dest = ResizeImage(Source, NewWidth, NewHeight))
                     Dest.Save(DestinationFile, encoder, parameters);
             }
             else
             {
                 // no need for resize
                 Source.Save(DestinationFile, encoder, parameters);
             }
         }
     }
     catch (Exception e)
     {
         File.Delete(DestinationFile); // make sure destination file doesn't exist anymore
         Console.WriteLine("Error: " + e.Message);
     }
 }

 private static ImageCodecInfo[] ConvertFromMemory(IntPtr memoryStart, int numCodecs)
 {
     ImageCodecInfo[] infoArray = new ImageCodecInfo[numCodecs];
     for (int i = 0; i < numCodecs; i++)
     {
         IntPtr lparam = (IntPtr) (((long) memoryStart) + (Marshal.SizeOf(typeof(ImageCodecInfoPrivate)) * i));
         ImageCodecInfoPrivate data = new ImageCodecInfoPrivate();
         System.Drawing.UnsafeNativeMethods.PtrToStructure(lparam, data);
         infoArray[i] = new ImageCodecInfo();
         infoArray[i].Clsid = data.Clsid;
         infoArray[i].FormatID = data.FormatID;
         infoArray[i].CodecName = Marshal.PtrToStringUni(data.CodecName);
         infoArray[i].DllName = Marshal.PtrToStringUni(data.DllName);
         infoArray[i].FormatDescription = Marshal.PtrToStringUni(data.FormatDescription);
         infoArray[i].FilenameExtension = Marshal.PtrToStringUni(data.FilenameExtension);
         infoArray[i].MimeType = Marshal.PtrToStringUni(data.MimeType);
         infoArray[i].Flags = (ImageCodecFlags) data.Flags;
         infoArray[i].Version = data.Version;
         infoArray[i].SignaturePatterns = new byte[data.SigCount][];
         infoArray[i].SignatureMasks = new byte[data.SigCount][];
         for (int j = 0; j < data.SigCount; j++)
         {
             infoArray[i].SignaturePatterns[j] = new byte[data.SigSize];
             infoArray[i].SignatureMasks[j] = new byte[data.SigSize];
             Marshal.Copy((IntPtr) (((long) data.SigMask) + (j * data.SigSize)), infoArray[i].SignatureMasks[j], 0, data.SigSize);
             Marshal.Copy((IntPtr) (((long) data.SigPattern) + (j * data.SigSize)), infoArray[i].SignaturePatterns[j], 0, data.SigSize);
         }
     }
     return infoArray;
 }

 static ExportBitmapCommand()
 {
     foreach (ImageCodecInfo ici in ImageCodecInfo.GetImageEncoders())
     {
         _jpegEncoder = ici;
     }
 }

 public Form1()
 {
     InitializeComponent();
     connected=false;
     encoderParams=new EncoderParameters();
     encoderParams.Param[0]=new EncoderParameter(System.Drawing.Imaging.Encoder.Quality,95L);
     jpegCodec=ImageCodecInfo.GetImageEncoders().First(codec=>codec.MimeType=="image/jpeg");
 }

		public void Save(FileStream fileStream, ImageCodecInfo encoder, int quality)
		{
			var encoderParams = new EncoderParameters(2);
			encoderParams.Param[0] = new EncoderParameter(Encoder.Quality, quality);			
			encoderParams.Param[1] = new EncoderParameter(Encoder.ColorDepth, 24L);				
			_bitmap.Save(fileStream, encoder, encoderParams);
			fileStream.Close();
		}

 public GetMapResponse(Image image, ImageCodecInfo codecInfo)
 {
     if (image == null)
         throw new ArgumentNullException("image");
     if (codecInfo == null)
         throw new ArgumentNullException("codecInfo");
     _image = image;
     _codecInfo = codecInfo;
 }

 static DevicePresenter()
 {
     ImageCodecInfo[] encoders = ImageCodecInfo.GetImageEncoders();
     for (int j = 0; j < encoders.Length; ++j)
     {
         if (encoders[j].MimeType == "image/jpeg")
             _codecInfo = encoders[j];
     }
 }

		public static ImageCodecInfo[] GetImageDecoders () 
		{
			Hashtable oldInfo = ImageCodec.Decoders;
			ImageCodecInfo [] newInfo = new ImageCodecInfo [oldInfo.Count];
			int i=0;
			foreach (ImageCodecInfo codec in oldInfo.Values) {
				newInfo [i++] = (ImageCodecInfo) codec.MemberwiseClone ();
			}
			return newInfo;
		}

		public static void SaveImage(Image image, string fileName, ImageCodecInfo jpgEncoder, EncoderParameters parameters)
		{
			RetryUtility.Retry(() => image.Save(fileName, jpgEncoder, parameters),
				RetryUtility.kDefaultMaxRetryAttempts,
				RetryUtility.kDefaultRetryDelay,
				new HashSet<Type>
				{
					Type.GetType("System.IO.IOException"),
					Type.GetType("System.Runtime.InteropServices.ExternalException")
				});
		}

 static AvatarBuilder()
 {
     ImageCodecInfo[] codecs = ImageCodecInfo.GetImageDecoders();
     foreach (ImageCodecInfo codec in codecs)
     {
         if (codec.FormatID == ImageFormat.Jpeg.Guid)
         {
             jpegImageCodeInfo = codec;
         }
     }
 }

 /// <summary>
 /// 质量控制
 /// </summary>
 /// <param name="level">级别，1-100</param>
 /// <param name="mimeType">图片格式，</param>
 private static void setQuality(int level, string mimeType)
 {
     var codecs = ImageCodecInfo.GetImageEncoders();
     ici = null;
     foreach (var codec in codecs)
     {
         if (codec.MimeType == "image/" + mimeType)
             ici = codec;
     }
     ep = new EncoderParameters();
     ep.Param[0] = new EncoderParameter(Encoder.Quality, level);
 }

		static void Check (ImageCodecInfo e, ImageCodecInfo d, Guid FormatID, string CodecName, string DllName,
			string FilenameExtension, ImageCodecFlags Flags, string FormatDescription,
			string MimeType, int Version, int signatureLength, string mask, string pattern, string pattern2)
		{
			Regex extRegex = new Regex (@"^(\*\.\w+(;(\*\.\w+))*;)?"+
				Regex.Escape (FilenameExtension)[email protected]"(;\*\.\w+(;(\*\.\w+))*)?$",
				RegexOptions.IgnoreCase | RegexOptions.Singleline);

			if (e != null) {
				Assert.AreEqual (FormatID, e.FormatID, "Encoder.FormatID");
				Assert.IsTrue (e.CodecName.IndexOf (CodecName)>=0,
					"Encoder.CodecName contains "+CodecName);
				Assert.AreEqual (DllName, e.DllName, "Encoder.DllName");
				Assert.IsTrue (extRegex.IsMatch (e.FilenameExtension),
					"Encoder.FilenameExtension is a right list with "+FilenameExtension);
				Assert.AreEqual (Flags, e.Flags, "Encoder.Flags");
				Assert.IsTrue (e.FormatDescription.IndexOf (FormatDescription)>=0,
					"Encoder.FormatDescription contains "+FormatDescription);
				Assert.IsTrue (e.MimeType.IndexOf (MimeType)>=0,
					"Encoder.MimeType contains "+MimeType);

				Assert.AreEqual (signatureLength, e.SignatureMasks.Length, "Encoder.SignatureMasks.Length");
				for (int i = 0; i < signatureLength; i++) {
					Assert.AreEqual (mask, BitConverter.ToString (e.SignatureMasks[i]), String.Format ("Encoder.SignatureMasks[{0}]", i));
				}
				Assert.AreEqual (signatureLength, e.SignaturePatterns.Length, "Encoder.SignaturePatterns.Length");
				Assert.AreEqual (pattern, BitConverter.ToString (e.SignaturePatterns[0]), "Encoder.SignaturePatterns[0]");
				if (pattern2 != null)
					Assert.AreEqual (pattern2, BitConverter.ToString (e.SignaturePatterns[1]), "Encoder.SignaturePatterns[1]");
			}
			if (d != null) {
				Assert.AreEqual (FormatID, d.FormatID, "Decoder.FormatID");
				Assert.IsTrue (d.CodecName.IndexOf (CodecName)>=0,
					"Decoder.CodecName contains "+CodecName);
				Assert.AreEqual (DllName, d.DllName, "Decoder.DllName");
				Assert.IsTrue (extRegex.IsMatch (d.FilenameExtension),
					"Decoder.FilenameExtension is a right list with "+FilenameExtension);
				Assert.AreEqual (Flags, d.Flags, "Decoder.Flags");
				Assert.IsTrue (d.FormatDescription.IndexOf (FormatDescription)>=0,
					"Decoder.FormatDescription contains "+FormatDescription);
				Assert.IsTrue (d.MimeType.IndexOf (MimeType)>=0,
					"Decoder.MimeType contains "+MimeType);

				Assert.AreEqual (signatureLength, d.SignatureMasks.Length, "Decoder.SignatureMasks.Length");
				for (int i = 0; i < signatureLength; i++) {
					Assert.AreEqual (mask, BitConverter.ToString (d.SignatureMasks[i]), String.Format ("Decoder.SignatureMasks[{0}]", i));
				}
				Assert.AreEqual (signatureLength, d.SignaturePatterns.Length, "Decoder.SignaturePatterns.Length");
				Assert.AreEqual (pattern, BitConverter.ToString (d.SignaturePatterns[0]), "Decoder.SignaturePatterns[0]");
				if (pattern2 != null)
					Assert.AreEqual (pattern2, BitConverter.ToString (d.SignaturePatterns[1]), "Decoder.SignaturePatterns[1]");
			}
		}

 static ControllerHelpers()
 {
     _MaxWidth = int.Parse(ConfigurationManager.AppSettings["UploadFileMaxWidth"]);
     _ThumbMaxWidth = int.Parse(ConfigurationManager.AppSettings["ThumbFileMaxWidth"]);
     _UserImgFolder = ConfigurationManager.AppSettings["UserImageFolder"];
     _JpegCodecInfo = ImageCodecInfo.GetImageEncoders().Where(codec => codec.MimeType == "image/jpeg").First();
     var qualityEncoder = Encoder.Quality;
     var quality = 100;
     var ratio = new EncoderParameter(qualityEncoder, quality);
     _EncoderParameters = new EncoderParameters(1);
     _EncoderParameters.Param[0] = ratio;
 }

        static ScanImg()
        {
            quality = new EncoderParameter(Encoder.Quality, 50L);

              ImageCodecInfo[] codecs = ImageCodecInfo.GetImageEncoders();
              for (int i = 0; i < codecs.Length; i++) {
            if (codecs[i].MimeType == "image/jpeg") {
              jpeg = codecs[i];
              break;
            } else
              jpeg = null;
              }
        }

        public ImageCodecAdapter(ImageCodecInfo codec)
        {
            this.codec = codec;
            this.parameters = new EncoderParameters {
                Param = new[] { new EncoderParameter(Encoder.Quality, 100L) }
            };

            this.FileExtensions = codec.FilenameExtension.Split(';')
                                                         .Select(e => e.TrimStart('*', '.').ToLowerInvariant())
                                                         .ToArray()
                                                         .AsReadOnly();
            this.MediaTypeNames = new[] { codec.MimeType }.AsReadOnly();
        }

        private void ConfigureImageQuality()
        {
            const long JPEGQUALITY = 20; // 1-100 or 0 for default

            myImageCodecInfo = GetEncoderInfo("image/jpeg");

            if (JPEGQUALITY != 0)
            {
                // If not using the default jpeg quality setting
                EncoderParameter myEncoderParameter = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, JPEGQUALITY);
                myEncoderParameters = new EncoderParameters(1);
                myEncoderParameters.Param[0] = myEncoderParameter;
            }
        }

        public ScreenCaptureWriter()
        {
            var codecs = ImageCodecInfo.GetImageDecoders();
            foreach (var imageCodecInfo in codecs)
            {
                if (imageCodecInfo.FormatID == ImageFormat.Jpeg.Guid)
                {
                    _imageCodecInfo = imageCodecInfo;
                    break;
                }
            }

            _encoder = Encoder.Quality;
            _encoderParams = new EncoderParameters(1);
            var qualityParam = new EncoderParameter(_encoder, 100L);
            _encoderParams.Param[0] = qualityParam;
        }

        public byte[] CompressBmpToJPEGArray(long CompressionRate, Bitmap aBitmap)
        {
            byte[] byteArray = new byte[0];
            MemoryStream stream = new MemoryStream();

            myImageCodecInfo = GetEncoderInfo("image/jpeg");
            myEncoder = System.Drawing.Imaging.Encoder.Quality;
            myEncoderParameters = new EncoderParameters(1);
            myEncoderParameter = new EncoderParameter(myEncoder, CompressionRate);
            myEncoderParameters.Param[0] = myEncoderParameter;

            aBitmap.Save(stream, myImageCodecInfo, myEncoderParameters);
            stream.Close();
            byteArray = stream.ToArray();

            return byteArray;
        }

        public frmQuickUpload()
        {
            Client.form_QuickUpload = this;
            encoder_params_jpg.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, 95L);

            ImageCodecInfo[] images = ImageCodecInfo.GetImageDecoders();

            // Get all the codecs for encoding the images.
            foreach(ImageCodecInfo codec in ImageCodecInfo.GetImageDecoders()) {
                if(codec.MimeType == "image/jpeg") {
                    codec_jpeg = codec;
                }
            }

            InitializeComponent();

            _panDropUpload.Height = 0;
            _panDropUpload.Visible = true;

            // Immediately hide the confirmation row.
            _tlpUploadTable.RowStyles[1].Height = 0;
            _panConfirmUpload.Visible = false;

            // Make the form load the previous saved height if there is any.
            int saved_win_height = Client.config.get<int>("frmquickupload.window.height");
            this.Height = (saved_win_height == 0) ? this.Height : saved_win_height;

            // Make sure the form is the correct size.  Windows XP's form widths are less than 7's.
            OperatingSystemInfo osi = Utilities.getOSInfo();
            if(osi.os.Contains("XP")) {
                Size min_size = new Size() {
                    Height = this.MinimumSize.Height - 8,
                    Width = this.MinimumSize.Width - 8
                };

                Size max_size = new Size() {
                    Height = this.MaximumSize.Height - 8,
                    Width = this.MaximumSize.Width - 8
                };

                this.MinimumSize = min_size;
                this.MaximumSize = max_size;
                this.Size = min_size;
            }
        }

        public Webcam(string ocu_ipAddress, CameraConfiguration config)
        {
            this.config = config;
            FilterInfoCollection videoDevices = new FilterInfoCollection(FilterCategory.VideoInputDevice);
            if (videoDevices.Count < 1)
                throw new Exception("No video input devices available");
            if (!string.IsNullOrEmpty(config.DeviceName))
                videoSource = new VideoCaptureDevice(config.DeviceName);
                //videoSource = new VideoCaptureDevice(videoDevices[1].MonikerString);
            else
            {
                videoSource = new VideoCaptureDevice(videoDevices[0].MonikerString);
            }

            updateWorker = new Timer();
            updateWorker.Elapsed += new ElapsedEventHandler(updateWorker_Elapsed);
            FrameRate = config.RCU_To_OCU_Framerate;
            JPEGQuality = config.JPEGQuality;
            isActive = false;
            jpegCodec = GetEncoderInfo("image/jpeg");
            videoSource.DesiredFrameSize = new Size(320, 240);
            videoSource.NewFrame += new NewFrameEventHandler(videoSource_NewFrame);
            udp_sender = new Comms.UDP_Sender(ocu_ipAddress, config.SendPort);
            raw_frame_queue = new Utility.UpdateQueue<byte[]>(-1);
        }