protected override Image GenerateImage(MediaFile videoFile, ThumbnailGenerationOptions options)
        {
            var baseImage = _thumbnailGenerator.Generate(videoFile, options).Image;

            var sizedImage = ResizeImage(baseImage, options.ImageSize.Width, options.ImageSize.Height);
            return sizedImage;
        }

		async public Task<bool> FixOrientationAsync(MediaFile file)
		{
			if (file == null)
				return false;
			try
			{

				var filePath = file.Path;
				var orientation = GetRotation(filePath);

				if (!orientation.HasValue)
					return false;

				Bitmap bmp = RotateImage(filePath, orientation.Value);
				var quality = 90;

				using (var stream = File.Open(filePath, FileMode.OpenOrCreate))
					await bmp.CompressAsync(Bitmap.CompressFormat.Png, quality, stream);

				bmp.Recycle();

				return true;
			}
			catch (Exception ex)
			{                               
				//ex.Report(); //Extension method for Xamarin.Insights
				return false;
			}
		}

        public IEnumerable<MediaSegment> Segment(FileInfo file, long fileId)
        {
            var source = new MediaFile(file.FullName);
            using (var engine = new Engine())
            {
                engine.GetMetadata(source);
                var progressMs = 0.0;
                while (progressMs < source.Metadata.Duration.TotalMilliseconds)
                {
                    var options = new ConversionOptions();
                    var endMs = Math.Min(progressMs + _segmentLengthMs, source.Metadata.Duration.TotalMilliseconds);

                    options.CutMedia(TimeSpan.FromMilliseconds(progressMs),
                        TimeSpan.FromMilliseconds(endMs));

                    var outputFile = Path.Combine(file.DirectoryName,
                        string.Format("{0}_audio_{1}ms.wav", file.Name, progressMs));

                    engine.Convert(source, new MediaFile(outputFile), options);
                    yield return new MediaSegment
                    {
                        FileId = fileId,
                        File = new FileInfo(outputFile),
                        OffsetMs = progressMs,
                        DurationMs = endMs - progressMs
                    };
                    progressMs = endMs;
                }
            }
        }

        public async Task<IMediaFile> PickPhotoAsync()
        {
            Debug.WriteLine("PickPhotoAsync: starting");
            // setup a task to get the results back from the delegate
            var mediaInfoTask = new TaskCompletionSource<NSDictionary>();

            // setup a UI Picker to show photos
            var picker = new UIImagePickerController();
            picker.SourceType = UIImagePickerControllerSourceType.PhotoLibrary;
            picker.MediaTypes = new string[] { UTType.Image };
            picker.AllowsEditing = false;
            picker.Delegate = new MediaDelegate { InfoTask = mediaInfoTask };
            // iPad should display the picker in a popover
            if (UIDevice.CurrentDevice.UserInterfaceIdiom == UIUserInterfaceIdiom.Pad)
                picker.ModalInPopover = true;
            var vc = GetViewController();
            Debug.WriteLine("PickPhotoAsync: displaying photo picker");
            vc.PresentViewController(picker, true, null);
            // wait to get the results back
            Debug.WriteLine("PickPhotoAsync: waiting for selected photo");
            var info = await mediaInfoTask.Task;
            var assetUrl = info[UIImagePickerController.ReferenceUrl] as NSUrl;
            Debug.WriteLine("PickPhotoAsync: photo selected {0}", assetUrl);
            var mediaFile = new MediaFile {Path = assetUrl.ToString()};
            Debug.WriteLine("PickPhotoAsync: returning created media file");
            return mediaFile;
        }

 private void ConvertMediaFile(MediaFile mediaFile, FileToSyncItemConfiguration path)
 {
     if (File.Exists(path.Destination.FullPath + PathUtils.Extension))
     {
         SyncItem parent = SyncItemProvider.GetSyncItem(path.Destination.FullPath + PathUtils.Extension);
         string name = String.IsNullOrEmpty(Path.GetFileNameWithoutExtension(mediaFile.Name))
             ? mediaFile.Name
             : Path.GetFileNameWithoutExtension(mediaFile.Name);
         string syncItemPath = Path.Combine(path.Destination.FullPath, name + PathUtils.Extension);
         if (File.Exists(syncItemPath))
         {
             SyncItem syncItem = SyncItemProvider.GetSyncItem(syncItemPath);
             if (mediaFile.Blob != syncItem.SharedValues[FileTemplateFields.Blob.FieldId])
             {
                 syncItem.AttachMediaFile(new FileInfo(mediaFile.FilePath));
                 syncItem = _serializationManager.UpdateStatistics(syncItem);
                 SyncItemProvider.SaveSyncItem(syncItem, syncItemPath);
             }
         }
         else
         {
             SyncItem item = _serializationManager.CreateSyncMediaItem(parent.ItemPath, path.Destination.Database, parent.ID, mediaFile.FilePath);
             SyncItemProvider.SaveSyncItem(item, syncItemPath);
         }
     }
 }

        // Returns the value of the FilePath for a given item
        // ** Example **
        // Given: MediaFile: Artist: Artist1, Album: Album1, Genre: Genre1, FileType: MP3, FileName: SongTitle.mp3
        // Order: FileType -> Genre -> Artist -> Album
        // (External usage) Base Directory: C:/Music
        // Returns: MP3/Genre1/Artist1/Album1/
        // Helps Create: C:/Music/MP3/Genre1/Artist1/Album1/SongTitle.mp3
        public string FilePath( MediaFile mf )
        {
            string filePath = "";

            foreach ( string folder in folderStructure.FolderCategories )
            {
                if ( folder == "Artist" )
                {
                    filePath += mf.Artist + @"/";
                }
                if ( folder == "Album" )
                {
                    filePath += mf.Album + @"/";
                }
                if ( folder == "FileType" )
                {
                    filePath += mf.FileType.Substring( 1, mf.FileType.Length - 1 ).ToUpper( ) + @"/";
                }
                if ( folder == "Genre" )
                {
                    filePath += mf.Genre + @"/";
                }
            }

            return filePath;
        }

        public static Dictionary<string, string> GetVideoInfo(string fileName)
        {
            var dic = new Dictionary<string, string>();
            var mediaFile = new MediaFile(fileName);

            dic.Add(VideoInfoConstants.FileName, mediaFile.Name);
            dic.Add(VideoInfoConstants.Format, mediaFile.General.Format);
            dic.Add(VideoInfoConstants.Duration, mediaFile.General.DurationString);
            dic.Add(VideoInfoConstants.Bitrate, mediaFile.General.Bitrate.ToInvariantString());

            if (mediaFile.Audio.Count > 0)
            {

                dic.Add(VideoInfoConstants.AudioFormat, mediaFile.Audio[0].Format);
                dic.Add(VideoInfoConstants.AudioBitrate, mediaFile.Audio[0].Bitrate.ToInvariantString());
                dic.Add(VideoInfoConstants.AudioChannels, mediaFile.Audio[0].Channels.ToInvariantString());
                dic.Add(VideoInfoConstants.AudioSamplingRate, mediaFile.Audio[0].SamplingRate.ToInvariantString());
            }

            if (mediaFile.Video.Count > 0)
            {

                dic.Add(VideoInfoConstants.VideoFormat, mediaFile.Video[0].Format);
                dic.Add(VideoInfoConstants.VideoBitrate, mediaFile.Video[0].Bitrate.ToInvariantString());
                dic.Add(VideoInfoConstants.VideoFrameRate, mediaFile.Video[0].FrameRate.ToInvariantString());
                dic.Add(VideoInfoConstants.VideoFrameSize, mediaFile.Video[0].FrameSize);
            }

            return dic;
        }

        public ObservableCollection<MediaFile> CreateViewable( string folderPath )
        {
            if ( !Directory.Exists( folderPath ) ) return null;

            fileLoader.ReadFolder( folderPath );

            foreach ( string file in fileLoader.Files )
            {
                try
                {
                    var mf = new MediaFile( TagLib.File.Create( file ) );
                    fullFilePathToMediaFile.Add( file, mf );
                    int lastSlashOffset = file.LastIndexOf( "\\" ) + 1;
                    string partialFile = file.Substring( lastSlashOffset );
                    partialFilePathToMediaFile.Add( partialFile, mf );
                    ocMediaFiles.Add( mf );
                }
                catch ( Exception ex )
                {
                    exceptionList.Add( new Tuple<string, string>( ex.Message + System.Environment.NewLine + ex.StackTrace, file ) );
                }
            }

            return ocMediaFiles;
        }

      /// <summary>
      /// Open file for playing
      /// </summary>
      /// <param name="sender"></param>
      /// <param name="e"></param>
      private void MenuOpenFile_OnClick(object sender, RoutedEventArgs e) {
         try {
            var objDialog = new OpenFileDialog() {
               Filter = "Media files| *.mp4; *.avi; *.mp3; *.wav; *.pl"
            };
            bool? result = objDialog.ShowDialog();
            if(result == true) {
               var objFileInfo = new FileInfo(objDialog.FileName);
               //rewrite current play list
               _PlayList = new PlayList();

               //if we opened playlist
               if(objFileInfo.Extension == ".pl") {
                  _PlayList.Open(objDialog.FileName);
                  UpdatePlayListView();
               }
               else {
                  //if we opened standart media file
                  var objMediaFile = new MediaFile(objFileInfo);
                  _PlayList.MediaFiles.Add(objMediaFile);
                  ListBoxPlayList.Items.Add(objMediaFile);
               }
               ListBoxPlayList.SelectedIndex = 0;
               ListBoxPlayList_OnMouseDoubleClick(sender, null);
            }
         }
         catch(Exception ex) {
            MessageBox.Show(ex.Message);
         }
      }

        private void LoadButton_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                OpenFileDialog openFile = new OpenFileDialog
                {
                    Filter = "Video files (*.mp4)|*.mp4",
                    FilterIndex = 1,
                    RestoreDirectory = true
                };

                if (openFile.ShowDialog() == true)
                {
                    Screen.Source = new Uri(openFile.FileName);
                    Screen.LoadedBehavior = MediaState.Pause;

                    inputFile = new MediaFile {Filename = openFile.FileName};
                }

                _firstPlay = true;
            }
            catch (Exception)
            {
                MessageBox.Show("Failed load video");
            }
        }

        public async Task<MediaFile> UploadMediaAsync(MediaUpload upload)
        {
            var blobId = await GetNewBlobIdAsync(upload.ContentType);
            var url = string.Format("{0}/content/{1}", BaseApiUrl, blobId);

            using (var client = new HttpClient())
            {
                var response = await client.PostAsync(url, upload.Content);
                if (!response.IsSuccessStatusCode) return null;
            }

            var media = new MediaFile
            {
                BlobId = blobId,
                ContentSize = upload.ContentSize,
                ContentType = upload.ContentType,
                Uploaded = DateTime.UtcNow
            };

            var inserted = _mediaRepository.Insert(media);
            _unit.Commit();

            Log.InfoFormat("Uploaded media to FooCDN.  Id={0} BlobId={1} ContentSize={2} ContentType={3} StorageType={4}", media.Id, media.BlobId, media.ContentSize, media.ContentType, media.StorageType);

            return inserted;
        }

        public void Can_CutVideo()
        {
            string filePath = @"{0}\Cut_Video_Test.mp4";
            string outputPath = string.Format(filePath, Path.GetDirectoryName(_outputFilePath));

            var inputFile = new MediaFile { Filename = _inputFilePath };
            var outputFile = new MediaFile { Filename = outputPath };

            using (var engine = new Engine())
            {
                engine.ConvertProgressEvent += engine_ConvertProgressEvent;
                engine.ConversionCompleteEvent += engine_ConversionCompleteEvent;

                engine.GetMetadata(inputFile);

                ConversionOptions options = new ConversionOptions();
                options.CutMedia(TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(25));

                engine.Convert(inputFile, outputFile, options);
                engine.GetMetadata(outputFile);
            }
            
            Assert.That(File.Exists(outputPath));
            // Input file is 33 seconds long, seeking to the 30th second and then 
            // attempting to cut another 25 seconds isn't possible as there's only 3 seconds
            // of content length, so instead the library cuts the maximumum possible.
        }

 protected override string GenerateKey(MediaFile videoFile, ThumbnailGenerationOptions options)
 {
     return string.Format("{0}_{1}_{2}",
         videoFile.Id,
         options.PointInTime.ResolveAgainst(videoFile.Duration).ToTicksString(),
         options.ImageSize);
 }

 async Task Recognise (MediaFile result)
 {
     if (result.Source == null)
         return;
     try {
         activityIndicator.IsRunning = true;
         if (!_tesseract.Initialized) {
             var initialised = await _tesseract.Init ("eng");
             if (!initialised)
                 return;
         }
         if (!await _tesseract.SetImage (result.Source))
             return;
     } catch (Exception ex) {
         DisplayAlert ("Error", ex.Message, "Cancel");
     } finally {
         activityIndicator.IsRunning = false;
     }
     TextLabel.Text = _tesseract.Text;
     var words = _tesseract.Results (PageIteratorLevel.Word);
     var symbols = _tesseract.Results (PageIteratorLevel.Symbol);
     var blocks = _tesseract.Results (PageIteratorLevel.Block);
     var paragraphs = _tesseract.Results (PageIteratorLevel.Paragraph);
     var lines = _tesseract.Results (PageIteratorLevel.Textline);
 }

        public void FileController_UpdateSEO_ShouldReturnChangesSaved()
        {
            FileController fileController = GetFileController();

            var mediaFile = new MediaFile();
            fileController.UpdateSEO(mediaFile, "test", "test").Should().Be("Changes saved");
        }

        /// <summary>
        /// Extracts season and episode number by using some regexes specified in patterns
        /// </summary>
        /// <param name="ie">Candidate which should be processed</param>
        /// <param name="patterns">Patterns to be used for recognition, supply these for speed reasons?</param>
        public static void ExtractSeasonAndEpisode(MediaFile ie, string[] patterns)
        {
            string strSeason = "";
            string strEpisode = "";
            Match m = null;
            int episode = -1;
            int season = -1;
            log.Debug("Extracting season and episode from " + ie.FilePath + Path.DirectorySeparatorChar + ie.Filename);
            //[MOVIES_TAGS_TO_REMOVE_LIST_KEY] and (CRCXXXXX) are removed for recognition, since they might produce false positives
            string cleanedname = Regex.Replace(ie.Filename, "\\[.*?\\]|\\(.{8}\\)", "");
            foreach (string pattern in patterns) {
                //Try to match. If it works, get the season and the episode from the match
                m = Regex.Match(cleanedname, pattern, RegexOptions.IgnoreCase | RegexOptions.RightToLeft);
                if (m.Success) {
                    log.Debug("This pattern produced a match: " + pattern);
                    strSeason = "";
                    strEpisode = "";
                    //ignore numbers like 2063, chance is higher they're a year than a valid season/ep combination
                    if (Int32.Parse(m.Groups["Season"].Value + m.Groups["Episode"].Value) > 2000 && (m.Groups["Season"].Value + m.Groups["Episode"].Value).StartsWith("20")) {
                        continue;
                    }
                    try {
                        strSeason = Int32.Parse(m.Groups["Season"].Value).ToString();
                    } catch (FormatException) {
                    }
                    try {
                        strEpisode = Int32.Parse(m.Groups["Episode"].Value).ToString();
                    } catch (FormatException) {
                    }
                    //Fix for .0216. notation for example, 4 numbers should always be recognized as %S%S%E%E (IF THEY ARENT A YEAR!)
                    if (strEpisode.Length == 3 && strSeason.Length == 1) {
                        strSeason += strEpisode[0];
                        strEpisode = strEpisode.Substring(1);
                        if (strSeason[0] == '0') {
                            strSeason = strSeason.Substring(1);
                        }
                    }

                    try {
                        episode = Int32.Parse(strEpisode);
                    } catch {
                        log.Debug("Cannot parse found episode: " + strEpisode);
                    }
                    try {
                        season = Int32.Parse(strSeason);
                    } catch {
                        log.Debug("Cannot parse found season: " + strSeason);
                    }

                    if ((ie.Filename.ToLower().Contains("720p") && season == 7 && episode == 20) | (ie.Filename.ToLower().Contains("1080p") && season == 10 && episode == 80)) {
                        season = -1;
                        episode = -1;
                        continue;
                    }
                    ie.SeasonNr = season;
                    ie.EpisodeNr = episode;
                    return;
                }
            }
        }

            public override bool BuildFrame(MediaFile file, MediaFrame mediaFrame, Stream buffer)
            {
               
                if (mediaFrame.IsBinaryHeader)
                {
                    buffer.Write(_videoCodecHeaderInit,0, _videoCodecHeaderInit.Length);
                }
                else
                {
                    if (mediaFrame.IsKeyFrame)
                    {
                        // video key frame
                        buffer.Write(_videoCodecHeaderKeyFrame, 0,_videoCodecHeaderKeyFrame.Length);
                    }
                    else
                    {
                        //video normal frame
                        buffer.Write(_videoCodecHeader, 0, _videoCodecHeader.Length);
                    }
                    mediaFrame.CompositionOffset = IPAddress.HostToNetworkOrder(mediaFrame.CompositionOffset & 0x00ffffff) >> 8;
                    buffer.Write(BitConverter.GetBytes(mediaFrame.CompositionOffset), 0, 3);
                }

                return base.BuildFrame(file, mediaFrame, buffer);
            }

        public IEnumerable<IMediaFile> GetMediaForProjectByType(int projectId, FileType type)
        {
            var wikiFiles = WikiFile.CurrentFiles(projectId);

            var mediaFiles = new List<MediaFile>();

            foreach (var wikiFile in wikiFiles)
            {
                var mediaFile = new MediaFile
                {
                    Current = wikiFile.Current,
                    Archived = wikiFile.Archived,
                    CreateDate = wikiFile.CreateDate,
                    Name = wikiFile.Name,
                    Id = wikiFile.Id,
                    CreatedBy = wikiFile.CreatedBy,
                    DotNetVersion = wikiFile.DotNetVersion,
                    Downloads = wikiFile.Downloads,
                    FileType = (FileType)Enum.Parse(typeof(FileType), wikiFile.FileType),
                    FileVersion = wikiFile.NodeVersion,
                    Path = wikiFile.Path,
                    RemovedBy = wikiFile.RemovedBy,
                    SupportsMediumTrust = false,
                    UmbVersion = wikiFile.Versions,
                    Verified = wikiFile.Verified
                };

                if (mediaFiles.Contains(mediaFile) == false)
                    mediaFiles.Add(mediaFile);
            }

            return mediaFiles;
        }

        public DateTime UpdateCreationDate(MediaFile mediaFile)
        {
            var originalCreationDate = GetOriginalCreationDate(mediaFile);

            UpdateCreationDate(mediaFile, originalCreationDate);

            return originalCreationDate;
        }

 public void LoadImage(string fileName)
 {
     var buf= new MediaFile(fileName);
     if (ByteToImageConverter.IsFileImage(buf))
     {
         this.File = buf;
     }
 }