/**
         * Return the dimension of this image
         *
         * @param is the stream Containing the image data
         * @param type type of the picture: {@link NPOI.SS.UserModel.Workbook#PICTURE_TYPE_JPEG},
         * {@link NPOI.SS.UserModel.Workbook#PICTURE_TYPE_PNG} or {@link NPOI.SS.UserModel.Workbook#PICTURE_TYPE_DIB}
         *
         * @return image dimension in pixels
         */
        public static Size GetImageDimension(Stream is1, PictureType type)
        {
            Size size = new Size();

            if (type == PictureType.JPEG || type == PictureType.PNG || type == PictureType.DIB)
            {
                //we can calculate the preferred size only for JPEG, PNG and BMP
                //other formats like WMF, EMF and PICT are not supported in Java
                using (Image img = Image.FromStream(is1))
                {
                    int[] dpi = GetResolution(img);

                    //if DPI is zero then assume standard 96 DPI
                    //since cannot divide by zero
                    if (dpi[0] == 0) dpi[0] = PIXEL_DPI;
                    if (dpi[1] == 0) dpi[1] = PIXEL_DPI;

                    size.Width = img.Width * PIXEL_DPI / dpi[0];
                    size.Height = img.Height * PIXEL_DPI / dpi[1];
                    return size;
                }
            }
            else
                logger.Log(POILogger.WARN, "Only JPEG, PNG and DIB pictures can be automatically sized");
            return size;
        }

 public static AttachedPictureFrame Get(TagLib.Id3v2.Tag tag, string description, PictureType type, bool create)
 {
     AttachedPictureFrame frame;
     IEnumerator<Frame> enumerator = tag.GetFrames(FrameType.APIC).GetEnumerator();
     try
     {
         while (enumerator.MoveNext())
         {
             Frame current = enumerator.Current;
             frame = current as AttachedPictureFrame;
             if (((frame != null) && ((description == null) || (frame.Description == description))) && ((type == PictureType.Other) || (frame.Type == type)))
             {
                 return frame;
             }
         }
     }
     finally
     {
         if (enumerator == null)
         {
         }
         enumerator.Dispose();
     }
     if (!create)
     {
         return null;
     }
     frame = new AttachedPictureFrame {
         Description = description,
         Type = type
     };
     tag.AddFrame(frame);
     return frame;
 }

        /// <summary>
        /// <see cref="MyCompany.Visitors.Client.IEmployeeService"/>
        /// </summary>
        /// <param name="pictureType"><see cref="MyCompany.Visitors.Client.IEmployeeService"/></param>
        /// <returns></returns>
        public async Task<Employee> GetLoggedEmployeeInfo(PictureType pictureType)
        {
            string url = String.Format(CultureInfo.InvariantCulture
              , "{0}api/employees/current/{1}", _urlPrefix, (int)pictureType);

            return await base.GetAsync<Employee>(url);
        }

        /// <summary>
        /// <see cref="MyCompany.Visitors.Client.IEmployeeService"/>
        /// </summary>
        /// <param name="employeeId"><see cref="MyCompany.Visitors.Client.IEmployeeService"/></param>
        /// <param name="pictureType"><see cref="MyCompany.Visitors.Client.IEmployeeService"/></param>
        /// <returns></returns>
        public async Task<Employee> Get(int employeeId, PictureType pictureType)
        {
            string url = String.Format(CultureInfo.InvariantCulture
              , "{0}api/employees/{1}/{2}", _urlPrefix, employeeId, (int)pictureType);

            return await base.GetAsync<Employee>(url);
        }

        /// <summary>
        /// <see cref="MyCompany.Visitors.Client.IVisitService"/>
        /// </summary>
        /// <param name="visitId"><see cref="MyCompany.Visitors.Client.IVisitService"/></param>
        /// <param name="pictureType"><see cref="MyCompany.Visitors.Client.IVisitService"/></param>
        /// <returns><see cref="MyCompany.Visitors.Client.IVisitService"/></returns>
        public async Task<Visit> Get(int visitId, PictureType pictureType)
        {
            string url = String.Format(CultureInfo.InvariantCulture
              , "{0}api/visits/{1}/{2}", _urlPrefix, visitId, (int)pictureType);

            return await base.GetAsync<Visit>(url);
        }

        /// <summary>
        /// <see cref="MyCompany.Visitors.Client.IVisitService"/>
        /// </summary>
        /// <param name="filter"><see cref="MyCompany.Visitors.Client.IVisitService"/></param>
        /// <param name="pictureType"><see cref="MyCompany.Visitors.Client.IVisitService"/></param>
        /// <param name="pageSize"><see cref="MyCompany.Visitors.Client.IVisitService"/></param>
        /// <param name="pageCount"><see cref="MyCompany.Visitors.Client.IVisitService"/></param>
        /// <param name="dateFilter"><see cref="MyCompany.Visitors.Client.IVisitService"/></param>
        /// <returns><see cref="MyCompany.Visitors.Client.IVisitService"/></returns>
        public async Task<IList<Visit>> GetUserVisits(string filter, PictureType pictureType, int pageSize, int pageCount, DateTime dateFilter)
        {
            string url = String.Format(CultureInfo.InvariantCulture
              , "{0}api/visits/user?filter={1}&pictureType={2}&pageSize={3}&pageCount={4}&dateFilter={5}", _urlPrefix, filter, (int)pictureType, pageSize, pageCount, dateFilter);

            return await base.GetAsync<IList<Visit>>(url);
        }

 public Picture(ByteVector data)
 {
     if (data == null)
     {
         throw new ArgumentNullException("data");
     }
     if (data.Count < 0x20)
     {
         throw new CorruptFileException("Data must be at least 32 bytes long");
     }
     int startIndex = 0;
     this.type = (PictureType) data.Mid(startIndex, 4).ToUInt();
     startIndex += 4;
     int count = (int) data.Mid(startIndex, 4).ToUInt();
     startIndex += 4;
     this.mime_type = data.ToString(StringType.Latin1, startIndex, count);
     startIndex += count;
     int num3 = (int) data.Mid(startIndex, 4).ToUInt();
     startIndex += 4;
     this.description = data.ToString(StringType.UTF8, startIndex, num3);
     startIndex += num3;
     this.width = (int) data.Mid(startIndex, 4).ToUInt();
     startIndex += 4;
     this.height = (int) data.Mid(startIndex, 4).ToUInt();
     startIndex += 4;
     this.color_depth = (int) data.Mid(startIndex, 4).ToUInt();
     startIndex += 4;
     this.indexed_colors = (int) data.Mid(startIndex, 4).ToUInt();
     startIndex += 4;
     int length = (int) data.Mid(startIndex, 4).ToUInt();
     startIndex += 4;
     this.picture_data = data.Mid(startIndex, length);
 }

        /// <summary>
        /// <see cref="MyCompany.Visitors.Client.IEmployeeService"/>
        /// </summary>
        /// <param name="filter"><see cref="MyCompany.Visitors.Client.IEmployeeService"/></param>
        /// <param name="pictureType"><see cref="MyCompany.Visitors.Client.IEmployeeService"/></param>
        /// <param name="pageSize"><see cref="MyCompany.Visitors.Client.IEmployeeService"/></param>
        /// <param name="pageCount"><see cref="MyCompany.Visitors.Client.IEmployeeService"/></param>
        /// <returns></returns>
        public async Task<IList<Employee>> GetEmployees(string filter, PictureType pictureType, int pageSize, int pageCount)
        {
            string url = String.Format(CultureInfo.InvariantCulture
              , "{0}api/employees/GetEmployees?filter={1}&pictureType={2}&pageSize={3}&pageCount={4}", _urlPrefix, filter, (int)pictureType, pageSize, pageCount);

            return await base.GetAsync<IList<Employee>>(url);
        }

 public override void Read(BitReader bitReader)
 {
     base.Read(bitReader);
       PrimaryPicType = (PictureType)bitReader.GetByteFromNBits(3);
       bitReader.DiscardTrailingBits(); // complete the byte
       while (MoreRBSPData(bitReader))
     bitReader.ReadByte();
 }

 public PictureFrame(byte[] raw_data, System.Drawing.Image image, string description, PictureType pictureType)
     : this(image, description, pictureType)
 {
     if(raw_data==null)
     {
         throw new ArgumentNullException("The passed image raw data can not be null.");
     }
     this._rawData = raw_data;
 }

		/// <summary>
		/// Creates a new instance of PictureFrame.
		/// </summary>
		/// <param name="encoding">the text encoding</param>
		/// <param name="mimeType">the MIME type</param>
		/// <param name="description">the description</param>
		/// <param name="picture">the picture type</param>
		/// <param name="data">the picture bytes</param>
		public PictureFrame(Encoding encoding, string mimeType, string description, PictureType picture, byte[] data)
		{
		    Descriptor.ID = "APIC";
			TextEncoding = encoding;
			MimeType = mimeType;
			Description = description;
			PictureCoding = picture;
			PictureData = data;
		}

 /// <summary>
 /// Creates a new instance of PictureFrame.
 /// </summary>
 /// <param name="encoding">the text encoding</param>
 /// <param name="mimeType">the MIME type</param>
 /// <param name="description">the description</param>
 /// <param name="picture">the picture type</param>
 /// <param name="data">the picture bytes</param>
 public PictureFrame(TextEncodingType encoding, string mimeType, string description, PictureType picture,
                     byte[] data)
 {
     TextEncoding = encoding;
     MimeType = mimeType;
     Description = description;
     PictureCoding = picture;
     PictureData = data;
 }

 /// <summary>
 /// Creates a new instance of PictureFrame.
 /// </summary>
 /// <param name="encoding">the text encoding</param>
 /// <param name="mimeType">the MIME type</param>
 /// <param name="description">the description</param>
 /// <param name="picture">the picture type</param>
 /// <param name="data">the picture bytes</param>
 public PictureFrame(Encoding encoding, string mimeType, string description, PictureType picture,
                     IList<byte> data)
 {
     Descriptor.Id = "APIC";
     TextEncoding = encoding;
     MimeType = mimeType;
     Description = description;
     PictureCoding = picture;
     PictureData = new ReadOnlyCollection<byte>(data);
 }

 public static string GetStringFromPictureType(PictureType pictureType)
 {
     foreach (KeyValuePair<string, PictureType> pair1 in PictureTypeHelper.m_PictureTypeDictionary)
     {
         if (((PictureType) pair1.Value) == pictureType)
         {
             return pair1.Key;
         }
     }
     return "Other";
 }

        private void ParseImage(byte[] data, PictureName name, PictureType type)
        {
            Image img = Image.FromStream(new MemoryStream(data));
            if (!_images.ContainsKey(name))
            {
                _images.Add(name, new Dictionary<PictureType, Image>());
            }

            if (_images[name].ContainsKey(type))
            {
                _images[name][type] = img;
            }
            else
            {
                _images[name].Add(type, img);
            }
        }

 public static extern char av_get_pict_type_char(PictureType pict_type);

        private string GetDefaultImageFileName(PictureType defaultPictureType = PictureType.Entity)
        {
            string defaultImageFileName;
            switch (defaultPictureType)
            {
                case PictureType.Entity:
                    defaultImageFileName = _settingService.GetSettingByKey("Media.DefaultImageName", "default-image.jpg");
                    break;
                case PictureType.Avatar:
                    defaultImageFileName = _settingService.GetSettingByKey("Media.Customer.DefaultAvatarImageName", "default-avatar.jpg");
                    break;
                default:
                    defaultImageFileName = _settingService.GetSettingByKey("Media.DefaultImageName", "default-image.jpg");
                    break;
            }

            return defaultImageFileName;
        }

        public virtual string GetPictureUrl(
            Picture picture,
            int targetSize = 0,
            bool showDefaultPicture = true,
            string storeLocation = null,
            PictureType defaultPictureType = PictureType.Entity)
        {
            string url = string.Empty;
            byte[] pictureBinary = null;
            if (picture != null)
                pictureBinary = LoadPictureBinary(picture);
            if (picture == null || pictureBinary == null || pictureBinary.Length == 0)
            {
                if (showDefaultPicture)
                {
                    url = GetDefaultPictureUrl(targetSize, defaultPictureType, storeLocation);
                }
                return url;
            }

            if (picture.IsNew)
            {
                _imageCache.DeleteCachedImages(picture);

                // we do not validate picture binary here to ensure that no exception ("Parameter is not valid") will be thrown
                picture = UpdatePicture(picture.Id,
                    pictureBinary,
                    picture.MimeType,
                    picture.SeoFilename,
                    false,
                    false);
            }

            url = this.GetProcessedImageUrl(
                pictureBinary,
                picture.Id,
                picture.SeoFilename,
                MimeTypes.MapMimeTypeToExtension(picture.MimeType),
                targetSize,
                storeLocation);

            return url;
        }

        public virtual string GetDefaultPictureUrl(int targetSize = 0, PictureType defaultPictureType = PictureType.Entity, string storeLocation = null)
        {
            string defaultImageFileName = GetDefaultImageFileName(defaultPictureType);

            string filePath = GetDefaultPictureLocalPath(defaultImageFileName);
            if (!File.Exists(filePath))
            {
                return string.Empty;
            }

            var url = this.GetProcessedImageUrl(
                filePath,
                0,
                Path.GetFileNameWithoutExtension(filePath),
                Path.GetExtension(filePath),
                targetSize,
                storeLocation);

            return url;
        }

 public AttachedPicture()
 {
     _pictureType = PictureType.CoverFront;
 }