Exemplo n.º 1
0
        public override void ViewDidLoad()
        {
            base.ViewDidLoad ();

            //largely taken from the xamarin website videoplayer tutorial

            //build the path to the location where the movie was saved
            var documents = Environment.GetFolderPath (Environment.SpecialFolder.MyDocuments);
            var library = System.IO.Path.Combine (documents, "..", "Library");
            var urlpath = System.IO.Path.Combine (library, "sweetMovieFilm.mov");

            NSUrl url = new NSUrl (urlpath, false);

            _asset = AVAsset.FromUrl(url);
            _playerItem = new AVPlayerItem (_asset);
            _player = new AVPlayer (_playerItem);

            _playerLayer = AVPlayerLayer.FromPlayer (_player);
            _playerLayer.Frame = View.Frame;
            View.Layer.AddSublayer (_playerLayer);

            //this code makes UI controls sit on top of the movie layer.  Allows you to just place the controls in interface builder
            UIView cameraView = new UIView ();
            this.View.AddSubview (cameraView);
            this.View.SendSubviewToBack (cameraView);
            cameraView.Layer.AddSublayer (_playerLayer);

            _player.Play ();

            this.btnDonePlaying.TouchUpInside += stopPlaying;
        }
		protected override void OnElementChanged (ElementChangedEventArgs<View> e)
		{
			base.OnElementChanged (e);

			//Get the video
			//bubble up to the AVPlayerLayer
			var url = new NSUrl ("http://www.androidbegin.com/tutorial/AndroidCommercial.3gp");
			_asset = AVAsset.FromUrl (url);

			_playerItem = new AVPlayerItem (_asset);

			_player = new AVPlayer (_playerItem);

			_playerLayer = AVPlayerLayer.FromPlayer (_player);

			//Create the play button
			playButton = new UIButton ();
			playButton.SetTitle ("Play Video", UIControlState.Normal);
			playButton.BackgroundColor = UIColor.Gray;

			//Set the trigger on the play button to play the video
			playButton.TouchUpInside += (object sender, EventArgs arg) => {
				_player.Play();
			};
		}
        public override void ViewDidLoad ()
        {
            base.ViewDidLoad ();
            
			LoadNotifications ();
			IsSeeking = false;
			_asset = AVAsset.FromUrl (NSUrl.FromFilename ("sample.m4v"));
			_playerItem = new AVPlayerItem (_asset);

			_player = new AVPlayer (_playerItem); 
			_playerItem.AddObserver (this, (NSString)"status", NSKeyValueObservingOptions.New|NSKeyValueObservingOptions.Initial, StatusObservationContext.Handle);
			_playerItem.AddObserver (this, (NSString)"playbackBufferFull", NSKeyValueObservingOptions.New|NSKeyValueObservingOptions.Initial, PlaybackBufferFullContext.Handle);
			_playerItem.AddObserver (this, (NSString)"playbackBufferEmpty", NSKeyValueObservingOptions.New|NSKeyValueObservingOptions.Initial, PlaybackBufferEmptyContext.Handle);
			_playerItem.AddObserver (this, (NSString)"playbackLikelyToKeepUp", NSKeyValueObservingOptions.New|NSKeyValueObservingOptions.Initial, PlaybackLikelyToKeepUpContext.Handle);

			_player.Muted = true;
            _playerLayer = AVPlayerLayer.FromPlayer (_player);
            _playerLayer.Frame = View.Frame;
            
            View.Layer.AddSublayer (_playerLayer);

			AddTapGesture ();
			InitScrubberTimer ();
			SyncScrubber ();
            
            _player.Play ();
			PlayButton.SetTitle ("Pause", UIControlState.Normal);
        }
Exemplo n.º 4
0
 private void BtnPlay_TouchUpInside(object sender, EventArgs e)
 {
     avAsset             = AVAsset.FromUrl(NSUrl.FromFilename("video.mp4"));
     avPlayerItem        = new AVPlayerItem(avAsset);
     avPlayer            = new AVPlayer(avPlayerItem);
     avPlayerLayer       = AVPlayerLayer.FromPlayer(avPlayer);
     avPlayerLayer.Frame = View.Frame;
     View.Layer.AddSublayer(avPlayerLayer);
     avPlayer.Play();
 }
Exemplo n.º 5
0
        private void UpdateSource()
        {
            if (Element.Source != null)
            {
                AVAsset asset = null;
                if (Element.Source.Scheme == null)
                {
                    // file path
                    asset = AVAsset.FromUrl(NSUrl.FromFilename(Element.Source.OriginalString));
                }
                else if (Element.Source.Scheme == "ms-appx")
                {
                    // used for a file embedded in the application package
                    asset = AVAsset.FromUrl(NSUrl.FromFilename(Element.Source.LocalPath.Substring(1)));
                }
                else if (Element.Source.Scheme == "ms-appdata")
                {
                    asset = AVAsset.FromUrl(NSUrl.FromFilename(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), Element.Source.LocalPath.Substring(1))));
                }
                else
                {
                    asset = AVUrlAsset.Create(NSUrl.FromString(Element.Source.ToString()), GetOptionsWithHeaders(Element.HttpHeaders));
                }

                AVPlayerItem item = new AVPlayerItem(asset);

                if (observer != null)
                {
                    if (_avPlayerViewController.Player != null && _avPlayerViewController.Player.CurrentItem != null)
                    {
                        _avPlayerViewController.Player.CurrentItem.RemoveObserver(observer, "status");
                    }

                    observer.Dispose();
                    observer = null;
                }

                observer = (NSObject)item.AddObserver("status", 0, ObserveStatus);

                if (_avPlayerViewController.Player != null)
                {
                    _avPlayerViewController.Player.ReplaceCurrentItemWithPlayerItem(item);
                }
                else
                {
                    _avPlayerViewController.Player = new AVPlayer(item);
                }

                if (Element.AutoPlay)
                {
                    _avPlayerViewController.Player.Play();
                    Element.CurrentState = MediaElementState.Playing;
                }
            }
        }
Exemplo n.º 6
0
        protected virtual void InitializeSource()
        {
            PlaybackSession.NaturalDuration    = TimeSpan.Zero;
            PlaybackSession.PositionFromPlayer = TimeSpan.Zero;

            if (Source == null)
            {
                return;
            }

            try
            {
                // Reset player
                TryDisposePlayer();
                InitializePlayer();

                PlaybackSession.PlaybackState = MediaPlaybackState.Opening;

                _player.CurrentItem?.RemoveObserver(this, new NSString("duration"), _player.Handle);
                _player.CurrentItem?.RemoveObserver(this, new NSString("status"), _player.Handle);
                _player.CurrentItem?.RemoveObserver(this, new NSString("loadedTimeRanges"), _player.Handle);

                if (Source is MediaPlaybackList)
                {
                    var items = ((MediaPlaybackList)Source).Items;
                    foreach (var item in items)
                    {
                        var asset = AVAsset.FromUrl(DecodeUri(item.Source.Uri));
                        _player.InsertItem(new AVPlayerItem(asset), null);
                    }
                }
                else
                {
                    var nsAsset       = AVAsset.FromUrl(DecodeUri(((MediaSource)Source).Uri));
                    var streamingItem = AVPlayerItem.FromAsset(nsAsset);

                    _player.ReplaceCurrentItemWithPlayerItem(streamingItem);
                }

                _player.CurrentItem.AddObserver(this, new NSString("duration"), NSKeyValueObservingOptions.Initial, _player.Handle);
                _player.CurrentItem.AddObserver(this, new NSString("status"), NSKeyValueObservingOptions.New | NSKeyValueObservingOptions.Initial, _player.Handle);
                _player.CurrentItem.AddObserver(this, new NSString("loadedTimeRanges"), NSKeyValueObservingOptions.Initial | NSKeyValueObservingOptions.New, _player.Handle);

                _player.CurrentItem.SeekingWaitsForVideoCompositionRendering = true;

                // Adapt pitch to prevent "metallic echo" when changing playback rate
                _player.CurrentItem.AudioTimePitchAlgorithm = AVAudioTimePitchAlgorithm.TimeDomain;

                MediaOpened?.Invoke(this, null);
            }
            catch (Exception ex)
            {
                OnMediaFailed(ex);
            }
        }
Exemplo n.º 7
0
		public AVReaderWriter (AVAsset asset, IVideoTransformer transformer)
		{
			if (asset == null)
				throw new ArgumentNullException ("asset");
			if (transformer == null)
				throw new ArgumentNullException ("transformer");

			this.asset = asset;
			this.transformer = transformer;
			cancellationTokenSrc = new CancellationTokenSource ();
		}
Exemplo n.º 8
0
        void SetSource()
        {
            _logger.Log("SetSource invoked.");

            AVAsset asset = null;

            if (Element.Source is UriVideoSource)
            {
                string uri = (Element.Source as UriVideoSource).Uri;

                if (!String.IsNullOrWhiteSpace(uri))
                {
                    asset = AVAsset.FromUrl(new NSUrl(uri));
                }
            }
            else if (Element.Source is FileVideoSource)
            {
                string uri = (Element.Source as FileVideoSource).File;

                if (!String.IsNullOrWhiteSpace(uri))
                {
                    asset = AVAsset.FromUrl(new NSUrl(uri));
                }
            }
            else if (Element.Source is ResourceVideoSource)
            {
                string path = (Element.Source as ResourceVideoSource).Path;

                if (!String.IsNullOrWhiteSpace(path))
                {
                    string directory = Path.GetDirectoryName(path);
                    string filename  = Path.GetFileNameWithoutExtension(path);
                    string extension = Path.GetExtension(path).Substring(1);
                    NSUrl  url       = NSBundle.MainBundle.GetUrlForResource(filename, extension, directory);
                    asset = AVAsset.FromUrl(url);
                }
            }

            if (asset != null)
            {
                playerItem = new AVPlayerItem(asset);
            }
            else
            {
                playerItem = null;
            }

            player.ReplaceCurrentItemWithPlayerItem(playerItem);

            if (playerItem != null && Element.AutoPlay)
            {
                player.Play();
            }
        }
        public void DecompressionSessionCreateTest()
        {
            TestRuntime.AssertSystemVersion(PlatformName.iOS, 8, 0, throwIfOtherPlatform: false);
            TestRuntime.AssertSystemVersion(PlatformName.MacOSX, 10, 8, throwIfOtherPlatform: false);
            TestRuntime.AssertSystemVersion(PlatformName.TvOS, 10, 2, throwIfOtherPlatform: false);

            using (var asset = AVAsset.FromUrl(NSBundle.MainBundle.GetUrlForResource("xamvideotest", "mp4")))
                using (var session = CreateSession(asset)){
                    Assert.IsNotNull(session, "Session should not be null");
                }
        }
Exemplo n.º 10
0
        public byte[] GenerateThumbImage(string url, long second)
        {
            AVAssetImageGenerator imageGenerator = new AVAssetImageGenerator(AVAsset.FromUrl((new Foundation.NSUrl(url))));

            imageGenerator.AppliesPreferredTrackTransform = true;
            CMTime  actualTime;
            NSError error;
            CGImage cgImage = imageGenerator.CopyCGImageAtTime(new CMTime(second, 1000000), out actualTime, out error);

            return(new UIImage(cgImage).AsPNG().ToArray());
        }
Exemplo n.º 11
0
        void ReadSampleBuffers(AVAsset asset)
        {
            NSError error;

            assetReader = AVAssetReader.FromAsset(asset, out error);

            if (error != null)
            {
                Console.WriteLine("Error creating Asset Reader: {0}", error.Description);
            }

            AVAssetTrack[] videoTracks = asset.TracksWithMediaType(AVMediaType.Video);
            AVAssetTrack   videoTrack  = videoTracks [0];

            CreateDecompressionSession(videoTrack);
            var videoTrackOutput = AVAssetReaderTrackOutput.Create(videoTrack, (AVVideoSettingsUncompressed)null);

            if (assetReader.CanAddOutput(videoTrackOutput))
            {
                assetReader.AddOutput(videoTrackOutput);
            }

            if (!assetReader.StartReading())
            {
                return;
            }

            while (assetReader.Status == AVAssetReaderStatus.Reading)
            {
                CMSampleBuffer sampleBuffer = videoTrackOutput.CopyNextSampleBuffer();
                if (sampleBuffer != null)
                {
                    VTDecodeFrameFlags flags = VTDecodeFrameFlags.EnableAsynchronousDecompression;
                    VTDecodeInfoFlags  flagOut;
                    decompressionSession.DecodeFrame(sampleBuffer, flags, IntPtr.Zero, out flagOut);

                    sampleBuffer.Dispose();
                    if (presentationTimes.Count >= 5)
                    {
                        bufferSemaphore.Wait();
                    }
                }
                else if (assetReader.Status == AVAssetReaderStatus.Failed)
                {
                    Console.WriteLine("Asset Reader failed with error: {0}", assetReader.Error.Description);
                }
                else if (assetReader.Status == AVAssetReaderStatus.Completed)
                {
                    Console.WriteLine("Reached the end of the video.");
                    ChangeStatus();
                    ReadSampleBuffers(asset);
                }
            }
        }
 public void Defaults()
 {
     using (NSUrl video_url = NSUrl.FromFilename(video_asset_path))
         using (AVAsset video_asset = AVAsset.FromUrl(video_url))
             using (AVAssetImageGenerator aig = new AVAssetImageGenerator(video_asset)) {
                 Assert.Null(aig.ApertureMode, "ApertureMode");
                 Assert.False(aig.AppliesPreferredTrackTransform, "AppliesPreferredTrackTransform");
                 Assert.That(aig.MaximumSize, Is.EqualTo(CGSize.Empty), "MaximumSize");
                 Assert.True(aig.RequestedTimeToleranceAfter.IsPositiveInfinity, "RequestedTimeToleranceAfter");
                 Assert.True(aig.RequestedTimeToleranceBefore.IsPositiveInfinity, "RequestedTimeToleranceBefore");
             }
 }
Exemplo n.º 13
0
        public ImageSource GenerateThumbImage(string url, long usecond)
        {
            AVAssetImageGenerator imageGenerator = new AVAssetImageGenerator(AVAsset.FromUrl((new Foundation.NSUrl(url))));

            imageGenerator.AppliesPreferredTrackTransform = true;
            CMTime  actualTime;
            NSError error;
            CGImage cgImage = imageGenerator.CopyCGImageAtTime(new CMTime(usecond, 1000000), out actualTime, out error);

            return(ImageSource.FromStream(() => new UIImage(cgImage).AsPNG().AsStream()));
            //ImageSource.FromStream(() => new UIImage(cgImage).AsPNG().AsStream());
        }
Exemplo n.º 14
0
		public override async void WindowControllerDidLoadNib (NSWindowController windowController)
		{
			base.WindowControllerDidLoadNib (windowController);
			
			// Add code to here after the controller has loaded the document window

			var filename = Path.Combine (NSBundle.MainBundle.BundlePath, "sample_iTunes.mov");

			NSUrl url = NSUrl.FromFilename ("/Users/kichang/Downloads/sample_iTunes.mov");
			asset = AVAsset.FromUrl (url);


			string[] keys = { "playable", "hasProtectedContent", "tracks", "duration" };

			Task task = asset.LoadValuesTaskAsync (keys);

			await task;

			NSError assetError;
			if (asset.StatusOfValue ("playable", out assetError) == AVKeyValueStatus.Failed) {
				return;
			}

			if (asset.Playable) {
				float height = asset.Tracks [0].NaturalSize.Height;
				float width = asset.Tracks [0].NaturalSize.Width;

				playerItem = new AVPlayerItem (asset);
				player = new AVPlayer ();
				playerLayer = AVPlayerLayer.FromPlayer (player);


				playerView.WantsLayer = true;
				playerView.Layer.BackgroundColor = new CGColor (1, 1, 1, 1);


				playerLayer.Frame = new RectangleF (0, 0, width, height);
				playerView.Frame = playerLayer.Frame;


				playerView.Layer.AddSublayer (playerLayer);


				player.ReplaceCurrentItemWithPlayerItem (playerItem);


				player.Play ();

			} 



		}
Exemplo n.º 15
0
        public void DecompressionSessionCreateTest()
        {
            if (!TestRuntime.CheckSystemAndSDKVersion(8, 0))
            {
                Assert.Ignore("Ignoring VideoToolbox tests: Requires iOS8+");
            }

            using (var asset = AVAsset.FromUrl(NSBundle.MainBundle.GetUrlForResource("xamvideotest", "mp4")))
                using (var session = CreateSession(asset)){
                    Assert.IsNotNull(session, "Session should not be null");
                }
        }
        protected override void OnElementChanged(ElementChangedEventArgs <View> e)
        {
            base.OnElementChanged(e);
            if (e.NewElement is VideoPlayer parentPlayer)
            {
                _player      = new AVPlayer();
                _playerLayer = AVPlayerLayer.FromPlayer(_player);

                _contentType = parentPlayer.ContentType;
                var url = _contentType == Constants.ContentType.Remote ? new NSUrl(parentPlayer.Source) : new NSUrl(parentPlayer.Source, false);
                _asset      = AVAsset.FromUrl(url);
                _playerItem = new AVPlayerItem(_asset);
                _player.ReplaceCurrentItemWithPlayerItem(_playerItem);

                videoLengthThread = new Thread(new ThreadStart(() =>
                {
                    _totalLength = _player.CurrentItem.Asset.Duration.Seconds;
                    InvokeOnMainThread(() =>
                    {
                        parentPlayer.SoundLength?.Invoke(this, _totalLength);
                    });
                }));
                videoLengthThread.Start();

                parentPlayer.Play += (sender, innere) =>
                {
                    if (videoLengthThread.IsAlive)
                    {
                        videoLengthThread.Abort();
                        _totalLength = _player.CurrentItem.Asset.Duration.Seconds;
                        parentPlayer.SoundLength?.Invoke(this, _totalLength);
                    }
                    StartTimeObserver(parentPlayer);
                    _player.Play();
                };

                parentPlayer.Pause += (sender, innere) =>
                {
                    _player.Pause();
                };

                parentPlayer.Stop += (sender, innere) =>
                {
                    EndTimeObserver();
                    _player.Stop();
                };

                parentPlayer.GoToTime += (sender, sec) =>
                {
                    _player.SeekAsync(CoreMedia.CMTime.FromSeconds(sec, Constants.NSEC_PER_SEC));
                };
            }
        }
        VTDecompressionSession CreateSession(AVAsset asset)
        {
            var videoTracks      = asset.TracksWithMediaType(AVMediaType.Video);
            var track            = videoTracks[0];
            var formatDescriptor = track.FormatDescriptions[0] as CMVideoFormatDescription;

            var session = VTDecompressionSession.Create(
                (sourceFrame, status, flags, buffer, presentationTimeStamp, presentationDuration) => {},
                formatDescriptor);

            return(session);
        }
        public void DecompressionSessionGetSupportedPropertiesTest()
        {
            TestRuntime.AssertSystemVersion(PlatformName.iOS, 8, 0, throwIfOtherPlatform: false);
            TestRuntime.AssertSystemVersion(PlatformName.MacOSX, 10, 8, throwIfOtherPlatform: false);
            TestRuntime.AssertSystemVersion(PlatformName.TvOS, 10, 2, throwIfOtherPlatform: false);

            using (var asset = AVAsset.FromUrl(NSBundle.MainBundle.GetUrlForResource("xamvideotest", "mp4")))
                using (var session = CreateSession(asset)) {
                    var supportedProps = session.GetSupportedProperties();
                    Assert.NotNull(supportedProps, "GetSupportedProperties");
                    Assert.That(supportedProps.Count, Is.GreaterThan(0), "GetSupportedProperties should be more than zero");
                }
        }
Exemplo n.º 19
0
        private void Play(int index)
        {
            Stop();
            Prepare();
            var songToPlay = _items.ElementAt(index);

            UpdateNowPlaying(songToPlay);
            var avasset      = AVAsset.FromUrl(NSUrl.FromString(songToPlay.SongUri.OriginalString));
            var avplayerItem = new AVPlayerItem(avasset);

            _avPlayer = new AVPlayer(avplayerItem);
            _avPlayer.Play();
        }
        UIImage ImageFor(AVAsset avAsset, double time)
        {
            AVAssetImageGenerator imageGenerator = AVAssetImageGenerator.FromAsset(avAsset);

            imageGenerator.AppliesPreferredTrackTransform = true;

            CMTime  actualTime;
            NSError error         = null;
            var     requestedTime = new CMTime((long)time, 100);

            using (CGImage posterImage = imageGenerator.CopyCGImageAtTime(requestedTime, out actualTime, out error))
                return(UIImage.FromImage(posterImage));
        }
Exemplo n.º 21
0
        public async Task Play(IMediaFile mediaFile = null)
        {
            if (mediaFile != null)
            {
                nsUrl = new NSUrl(mediaFile.Url);
            }

            if (Status == MediaPlayerStatus.Paused)
            {
                Status = MediaPlayerStatus.Playing;
                //We are simply paused so just start again
                Player.Play();
                return;
            }

            try
            {
                // Start off with the status LOADING.
                Status = MediaPlayerStatus.Buffering;

                var nsAsset       = AVAsset.FromUrl(nsUrl);
                var streamingItem = AVPlayerItem.FromAsset(nsAsset);

                Player.CurrentItem?.RemoveObserver(this, new NSString("status"));

                Player.ReplaceCurrentItemWithPlayerItem(streamingItem);
                streamingItem.AddObserver(this, new NSString("status"), NSKeyValueObservingOptions.New, Player.Handle);
                streamingItem.AddObserver(this, new NSString("loadedTimeRanges"),
                                          NSKeyValueObservingOptions.Initial | NSKeyValueObservingOptions.New, Player.Handle);

                Player.CurrentItem.SeekingWaitsForVideoCompositionRendering = true;
                Player.CurrentItem.AddObserver(this, (NSString)"status", NSKeyValueObservingOptions.New |
                                               NSKeyValueObservingOptions.Initial,
                                               StatusObservationContext.Handle);

                NSNotificationCenter.DefaultCenter.AddObserver(AVPlayerItem.DidPlayToEndTimeNotification,
                                                               notification => MediaFinished?.Invoke(this, new MediaFinishedEventArgs(mediaFile)), Player.CurrentItem);

                Player.Play();
            }
            catch (Exception ex)
            {
                OnMediaFailed();
                Status = MediaPlayerStatus.Stopped;

                //unable to start playback log error
                Console.WriteLine("Unable to start playback: " + ex);
            }

            await Task.CompletedTask;
        }
        public bool CanReadRecordingMetadata(string localFilePath)
        {
            try
            {
                using (AVAsset asset = AVAsset.FromUrl(NSUrl.FromFilename(localFilePath)))
                    return(isRecording(asset));
            }
            catch (Exception ex)
            {
                Logger.Log("ERROR: LocalLibrary.CanReadRecordingMetadata: " + ex);
            }

            return(false);
        }
Exemplo n.º 23
0
        private Task <AVAsset> LoadAsset(AtomVideoSource source)
        {
            if (source.Url != null)
            {
                return(Task.FromResult(AVAsset.FromUrl(new NSUrl(source.Url))));
            }

            if (source.FilePath != null)
            {
                return(Task.FromResult(AVAsset.FromUrl(new NSUrl(source.FilePath, false))));
            }

            throw new NotImplementedException();
        }
Exemplo n.º 24
0
        private void SetSource()
        {
            try
            {
                if (string.IsNullOrWhiteSpace(Element.Source))
                {
                    return;
                }
                _prepared = false;
                if (_player != null)
                {
                    _player.Dispose();
                    _player = null;
                }

                AVPlayerItem playerItem = null;
                if (Element.Source.StartsWith("http://") || Element.Source.StartsWith("https://"))
                {
                    playerItem = new AVPlayerItem(AVAsset.FromUrl(NSUrl.FromString(Element.Source)));
                }
                else
                {
                    playerItem = new AVPlayerItem(NSUrl.FromFilename(Element.Source));
                }

                NSNotificationCenter.DefaultCenter.AddObserver(AVPlayerItem.DidPlayToEndTimeNotification, DidVideoFinishPlaying, playerItem);
                NSNotificationCenter.DefaultCenter.AddObserver(AVPlayerItem.ItemFailedToPlayToEndTimeNotification, DidVideoErrorOcurred, playerItem);
                NSNotificationCenter.DefaultCenter.AddObserver(AVPlayerItem.NewErrorLogEntryNotification, DidVideoErrorOcurred, playerItem);
                //NSNotificationCenter.DefaultCenter.AddObserver(AVPlayerItem.PlaybackStalledNotification, DidVideoPrepared, playerItem);

                _player = new AVPlayer(playerItem);
                _player.ActionAtItemEnd  = AVPlayerActionAtItemEnd.None;
                _playerController.Player = _player;
                _prepared = true;

                if (Element.AutoPlay)
                {
                    _player.Play();
                }

                if (_player.Error != null)
                {
                    Element.OnError(_playerController?.Player?.Error?.LocalizedDescription);
                }
            }
            catch (Exception e)
            {
                Element.OnError(e.Message);
            }
        }
Exemplo n.º 25
0
        private async Task<MediaFile> GetMovieMediaFile(NSDictionary info)
        {
            var url = (NSUrl)info[UIImagePickerController.MediaURL];

            var path = GetOutputPath(MediaImplementation.TypeMovie,
                      options.Directory ?? ((IsCaptured) ? string.Empty : "temp"),
                      options.Name ?? Path.GetFileName(url.Path));

            try
            {
                File.Move(url.Path, path);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Unable to move file, trying to copy. {ex.Message}");
                try
                {
                    File.Copy(url.Path, path);
                    File.Delete(url.Path);
                }
                catch (Exception)
                {
                    Console.WriteLine($"Unable to copy/delete file, will be left around :( {ex.Message}");
                }
            }

            string aPath = path;
            if (source != UIImagePickerControllerSourceType.Camera)
            {
                //try to get the album path's url
                var url2 = (NSUrl)info[UIImagePickerController.ReferenceUrl];
                aPath = url2?.AbsoluteString;
            }
            else
            {
                if (options.SaveToAlbum)
				{
					PhotoLibraryAccess.SaveVideoToGalery(url, path, options.Directory);
				}
			}

            var asset = AVAsset.FromUrl(new NSUrl($"file://{path}"));
            var duration = asset.Duration.Seconds;

            return new MediaFile(path, () => File.OpenRead(path), albumPath: aPath)
            {
                Type = MediaType.Video,
                Duration = duration,
            };
        }
Exemplo n.º 26
0
        protected virtual void InitializeSource()
        {
            PlaybackSession.NaturalDuration    = TimeSpan.Zero;
            PlaybackSession.PositionFromPlayer = TimeSpan.Zero;

            if (Source == null)
            {
                return;
            }

            try
            {
                // Reset player
                TryDisposePlayer();
                InitializePlayer();

                PlaybackSession.PlaybackState = MediaPlaybackState.Opening;

                var nsAsset       = AVAsset.FromUrl(DecodeUri(((MediaSource)Source).Uri));
                var streamingItem = AVPlayerItem.FromAsset(nsAsset);

                _player.CurrentItem?.RemoveObserver(this, new NSString("duration"), _player.Handle);
                _player.CurrentItem?.RemoveObserver(this, new NSString("status"), _player.Handle);
                _player.CurrentItem?.RemoveObserver(this, new NSString("loadedTimeRanges"), _player.Handle);

                _player.ReplaceCurrentItemWithPlayerItem(streamingItem);

                _player.CurrentItem.AddObserver(this, new NSString("duration"), NSKeyValueObservingOptions.Initial, _player.Handle);
                _player.CurrentItem.AddObserver(this, new NSString("status"), NSKeyValueObservingOptions.New | NSKeyValueObservingOptions.Initial, _player.Handle);
                _player.CurrentItem.AddObserver(this, new NSString("loadedTimeRanges"), NSKeyValueObservingOptions.Initial | NSKeyValueObservingOptions.New, _player.Handle);

                _player.CurrentItem.SeekingWaitsForVideoCompositionRendering = true;

                // Adapt pitch to prevent "metallic echo" when changing playback rate
                _player.CurrentItem.AudioTimePitchAlgorithm = AVAudioTimePitchAlgorithm.TimeDomain;

                // Disable subtitles if any
                var mediaSelectionGroup = _player.CurrentItem.Asset.MediaSelectionGroupForMediaCharacteristic(AVMediaCharacteristic.Legible);
                if (mediaSelectionGroup != null)
                {
                    _player.CurrentItem.SelectMediaOption(null, mediaSelectionGroup);
                }

                MediaOpened?.Invoke(this, null);
            }
            catch (Exception ex)
            {
                OnMediaFailed(ex);
            }
        }
Exemplo n.º 27
0
        void InitializePlayer()
        {
            ShouldDisposeView = true;

            if (DownloadedFile != null)
            {
                PlayerItem = new AVPlayerItem(DownloadedFile);
            }
            else if (Path.IsUrl())
            {
                PlayerItem = new AVPlayerItem(new NSUrl(Path));
            }
            else
            {
                PlayerItem = new AVPlayerItem(AVAsset.FromUrl(NSUrl.FromString("file://" + IO.File(Path).FullName)));
            }

            Player = new AVPlayer(PlayerItem)
            {
                Volume = 1.0f
            };

            DidPlayToEndTimeObservation = AVPlayerItem.Notifications.ObserveDidPlayToEndTime(PlayerItem, (_, _) =>
            {
                Thread.UI.Post(() => Dispose());
            });

            StatusObservation = PlayerItem.AddObserver(nameof(AVPlayerItem.Status), 0, _ =>
            {
                if (PlayerItem?.Status == AVPlayerItemStatus.ReadyToPlay)
                {
                    try { Audio.ConfigureAudio(AVAudioSessionCategory.Playback); }
                    catch { }

                    Player?.Play();
                    return;
                }

                if (PlayerItem?.Status == AVPlayerItemStatus.Failed)
                {
                    Log.For(this).Error($"Failed to play {Path}");
                }
                else
                {
                    Log.For(this).Error($"An error occured during playing {Path}");
                }

                RetryToDownloadTrack();
            });
        }
Exemplo n.º 28
0
        public void DecompressionSessionGetSupportedPropertiesTest()
        {
            if (!TestRuntime.CheckSystemAndSDKVersion(8, 0))
            {
                Assert.Ignore("Ignoring VideoToolbox tests: Requires iOS8+");
            }

            using (var asset = AVAsset.FromUrl(NSBundle.MainBundle.GetUrlForResource("xamvideotest", "mp4")))
                using (var session = CreateSession(asset)) {
                    var supportedProps = session.GetSupportedProperties();
                    Assert.NotNull(supportedProps, "GetSupportedProperties");
                    Assert.That(supportedProps.Count > 0, "GetSupportedProperties should be more than zero");
                }
        }
        public Orientation GetVideoOrientation(string filePath)
        {
            var url    = NSUrl.CreateFileUrl(filePath, false, null);
            var asset  = AVAsset.FromUrl(url);
            var tracks = asset.TracksWithMediaType(AVMediaType.Video);

            if (tracks.Length == 0)
            {
                return(Orientation.Unknown);
            }

            var track = tracks[0];

            return(GetVideoOrientation(track.PreferredTransform));
        }
Exemplo n.º 30
0
        public override void ViewDidLoad()
        {
            base.ViewDidLoad();

            asset      = AVAsset.FromUrl(NSUrl.FromFilename("sample.m4v"));
            playerItem = new AVPlayerItem(asset);

            player            = new AVPlayer(playerItem);
            playerLayer       = AVPlayerLayer.FromPlayer(player);
            playerLayer.Frame = View.Frame;

            View.Layer.AddSublayer(playerLayer);

            player.Play();
        }
Exemplo n.º 31
0
        public override void ViewDidLoad()
        {
            base.ViewDidLoad ();

            _asset = AVAsset.FromUrl (NSUrl.FromFilename ("sample.m4v"));
            _playerItem = new AVPlayerItem (_asset);

            _player = new AVPlayer (_playerItem);
            _playerLayer = AVPlayerLayer.FromPlayer (_player);
            _playerLayer.Frame = View.Frame;

            View.Layer.AddSublayer (_playerLayer);

            _player.Play ();
        }
Exemplo n.º 32
0
        protected override void OnElementChanged(ElementChangedEventArgs <View> e)
        {
            base.OnElementChanged(e);

            _asset      = AVAsset.FromUrl(NSUrl.FromFilename("intro.mp4"));
            _playerItem = new AVPlayerItem(_asset);

            _player = new AVPlayer(_playerItem);
            _player.ActionAtItemEnd = AVPlayerActionAtItemEnd.None;
            _playerLayer            = AVPlayerLayer.FromPlayer(_player);

            videoEndNotificationToken = NSNotificationCenter.DefaultCenter.AddObserver(AVPlayerItem.DidPlayToEndTimeNotification, VideoDidFinishPlaying, _playerItem);

            _player.Play();
        }
Exemplo n.º 33
0
        public AVReaderWriter(AVAsset asset, IVideoTransformer transformer)
        {
            if (asset == null)
            {
                throw new ArgumentNullException("asset");
            }
            if (transformer == null)
            {
                throw new ArgumentNullException("transformer");
            }

            this.asset           = asset;
            this.transformer     = transformer;
            cancellationTokenSrc = new CancellationTokenSource();
        }
 public void CopyCGImageAtTime_Invalid()
 {
     // Mov file is not supported by CopCGImageAtTime so we can test out error param
     using (NSUrl video_url = NSUrl.FromFilename(does_not_exists_asset_path))
         using (AVAsset video_asset = AVAsset.FromUrl(video_url))
             using (AVAssetImageGenerator aig = new AVAssetImageGenerator(video_asset)) {
                 // signature errors see https://bugzilla.xamarin.com/show_bug.cgi?id=5218
                 CMTime  actual;
                 NSError error;
                 var     img = aig.CopyCGImageAtTime(CMTime.Zero, out actual, out error);
                 Assert.Null(img, "missing");
                 Assert.True(actual.IsInvalid, "actual");
                 Assert.NotNull(error, "error");
             }
 }
Exemplo n.º 35
0
        public void LoadAsync(string source)
        {
            AVAsset asset;

            if (string.IsNullOrWhiteSpace(source))
            {
                return;
            }
            _prepared = false;
            if (audioPlayer != null)
            {
                audioPlayer.Dispose();
                audioPlayer = null;
            }
            _prepared = false;
            _timer    = new System.Timers.Timer(1000)
            {
                AutoReset = true
            };

            if (source.StartsWith("http://", StringComparison.CurrentCultureIgnoreCase) ||
                source.StartsWith("https://", StringComparison.CurrentCultureIgnoreCase))
            {
                asset = AVAsset.FromUrl(NSUrl.FromString(source));
            }
            else
            {
                asset = AVAsset.FromUrl(NSUrl.FromFilename(source));
            }

            var playerItem = new AVPlayerItem(asset);

            audioPlayer = new AVPlayer(playerItem);

            NSNotificationCenter.DefaultCenter.AddObserver(AVPlayerItem.DidPlayToEndTimeNotification, DidVideoFinishPlaying, playerItem);
            //NSNotificationCenter.DefaultCenter.AddObserver(AVPlayerItem.ItemFailedToPlayToEndTimeNotification, DidVideoErrorOcurred, playerItem);
            //NSNotificationCenter.DefaultCenter.AddObserver(AVPlayerItem.NewErrorLogEntryNotification, DidVideoErrorOcurred, playerItem);

            _timer.Elapsed += (s, e) =>
            {
                if (SeekPositionChanged != null)
                {
                    SeekPositionChanged.Invoke(this, CurrentPosition);
                }
            };
            _prepared = true;
            SetTotalDuration();
        }
        public async Task <IMediaFile> ExtractMediaInfo(IMediaFile mediaFile)
        {
            try
            {
                if (mediaFile.ExtractMetadata)
                {
                    var assetsToLoad = new List <string>
                    {
                        AVMetadata.CommonKeyArtist,
                        AVMetadata.CommonKeyTitle,
                        AVMetadata.CommonKeyArtwork
                    };

                    var url = MediaFileUrlHelper.GetUrlFor(mediaFile);

                    // Default title to filename
                    mediaFile.Metadata.Title = url.LastPathComponent;

                    var asset = AVAsset.FromUrl(url);
                    await asset.LoadValuesTaskAsync(assetsToLoad.ToArray());

                    foreach (var avMetadataItem in asset.CommonMetadata)
                    {
                        if (avMetadataItem.CommonKey == AVMetadata.CommonKeyArtist)
                        {
                            mediaFile.Metadata.Artist = ((NSString)avMetadataItem.Value).ToString();
                        }
                        else if (avMetadataItem.CommonKey == AVMetadata.CommonKeyTitle)
                        {
                            mediaFile.Metadata.Title = ((NSString)avMetadataItem.Value).ToString();
                        }
                        else if (avMetadataItem.CommonKey == AVMetadata.CommonKeyArtwork)
                        {
#if __IOS__ || __TVOS__
                            var image = UIImage.LoadFromData(avMetadataItem.DataValue);
                            mediaFile.Metadata.AlbumArt = image;
#endif
                        }
                    }
                    mediaFile.MetadataExtracted = true;
                }
                return(mediaFile);
            }
            catch (Exception)
            {
                return(mediaFile);
            }
        }
Exemplo n.º 37
0
        public override void AwakeFromNib()
        {
            base.AwakeFromNib();
            _asset = AVAsset.FromUrl(NSUrl.FromFilename("video.mp4"));
            _playerItem = new AVPlayerItem(_asset);
            _player = new AVPlayer(_playerItem);

            image = new UIImageView(UIImage.FromFile("Icon-76.png"));
            label.Font = UIFont.FromName("Cochin-BoldItalic", 22f);
            label.TextColor = UIColor.FromRGB(127, 51, 0);
            label.BackgroundColor = UIColor.Clear;
            LayoutIfNeeded();
            _playerLayer = AVPlayerLayer.FromPlayer(_player);
            
            _player.ExternalPlaybackVideoGravity = AVLayerVideoGravity.ResizeAspectFill;
        }
		private void initializeVideo()
		{
			var documents = Environment.GetFolderPath (Environment.SpecialFolder.MyDocuments);
			var library = System.IO.Path.Combine (documents, "..", "Library");
			var urlpath = System.IO.Path.Combine (library, "sweetMovieFilm.mov");

			url = new NSUrl (urlpath, false);

			_asset = AVAsset.FromUrl(url);
			_playerItem = new AVPlayerItem (_asset);


			_player = new AVPlayer (_playerItem);

			_notificationHandle = NSNotificationCenter.DefaultCenter.AddObserver (AVPlayerItem.DidPlayToEndTimeNotification, VideoDonePlaying);


			_playerLayer = AVPlayerLayer.FromPlayer (_player);
			_playerLayer.Frame = View.Frame;


		}
 public void DisposeVideoPlayer()
 {
     if (!_playerLoaded || _player == null)
     {
         return;
     }
     if (_positionDisplayTimer != null)
     {
         _positionDisplayTimer.Stop();
     }
     _player.Pause();
     _playerLoaded = false;
     _asset = null;
     _playerItem = null;
     _playerLayer = null;
     _player = null;
 }
Exemplo n.º 40
0
		public AVReaderWriter (AVAsset asset)
		{
			_asset = asset;
			_cancellationTokenSrc = new CancellationTokenSource ();
		}
Exemplo n.º 41
0
        void ReadSampleBuffers(AVAsset asset)
        {
            NSError error;
            assetReader = AVAssetReader.FromAsset (asset, out error);

            if (error != null)
                Console.WriteLine ("Error creating Asset Reader: {0}", error.Description);

            AVAssetTrack[] videoTracks = asset.TracksWithMediaType (AVMediaType.Video);
            AVAssetTrack videoTrack = videoTracks [0];
            CreateDecompressionSession (videoTrack);
            var videoTrackOutput = AVAssetReaderTrackOutput.Create (videoTrack, (AVVideoSettingsUncompressed)null);

            if (assetReader.CanAddOutput (videoTrackOutput))
                assetReader.AddOutput (videoTrackOutput);

            if (!assetReader.StartReading ())
                return;

            while (assetReader.Status == AVAssetReaderStatus.Reading) {
                CMSampleBuffer sampleBuffer = videoTrackOutput.CopyNextSampleBuffer ();
                if (sampleBuffer != null) {
                    VTDecodeFrameFlags flags = VTDecodeFrameFlags.EnableAsynchronousDecompression;
                    VTDecodeInfoFlags flagOut;
                    decompressionSession.DecodeFrame (sampleBuffer, flags, IntPtr.Zero, out flagOut);

                    sampleBuffer.Dispose ();
                    if (presentationTimes.Count >= 5)
                        bufferSemaphore.Wait ();

                } else if (assetReader.Status == AVAssetReaderStatus.Failed) {
                    Console.WriteLine ("Asset Reader failed with error: {0}", assetReader.Error.Description);
                } else if (assetReader.Status == AVAssetReaderStatus.Completed) {
                    Console.WriteLine("Reached the end of the video.");
                    ChangeStatus ();
                    ReadSampleBuffers (asset);
                }
            }
        }
		void loadAsset(AVAsset asset, string[] assetKeysToLoad, DispatchGroup dispatchGroup)
		{
			dispatchGroup.Enter ();
			asset.LoadValuesAsynchronously (assetKeysToLoad, () => {
				foreach(var key in assetKeysToLoad)
				{
					NSError error;
					if(asset.StatusOfValue(key, out error) == AVKeyValueStatus.Failed)
					{
						Console.Error.WriteLine("Key value loading failed for key" + key + " with error: "+ error.ToString());
						dispatchGroup.Leave();
					}

				}
				if(!asset.Composable)
				{
					Console.Error.WriteLine("Asset is not composable");
					dispatchGroup.Leave();
				}
				Clips.Add(asset);
				ClipTimeRanges.Add(NSValue.FromCMTimeRange(new CMTimeRange(){
					Start =  CMTime.FromSeconds(0, 1),
					Duration =  CMTime.FromSeconds(5,1)
				}));
				dispatchGroup.Leave();
			});
		}
        public void Open(string videoFileName)
        {
            _playerLoaded = false;
            if (_player != null)
            {
                try
                {
                    _player.Pause();
                    _player.Dispose();
                    _player = null;
                    foreach (var subView in View.VideoView.Subviews)
                    {
                        subView.RemoveFromSuperview();
                    }
                    foreach (var subLayer in View.VideoView.Layer.Sublayers)
                    {
                        subLayer.RemoveFromSuperLayer();
                    }
                    _playerLayer.Dispose();
                    _playerItem.Dispose();
                    _asset.Dispose();
                }
                catch
                {
                }
            }
            ShowPlayImage(false);
            _asset = AVAsset.FromUrl(NSUrl.FromFilename(videoFileName));
            _playerItem = new AVPlayerItem(_asset);
            _player = new AVPlayer(_playerItem);
            _playerLayer = AVPlayerLayer.FromPlayer(_player);
            _videoView = new NSMyVideoView(new CoreGraphics.CGRect(0, 0, View.VideoView.Frame.Width, View.VideoView.Frame.Width), View.VideoView, _playerLayer);
            _videoView.WantsLayer = true;
            View.VideoView.AddSubview(_videoView);
            View.VideoView.WantsLayer = true;
            _playerLayer.Frame = View.VideoView.Bounds;
            View.VideoView.Layer.AddSublayer(_playerLayer);
           _videoView.ResizeWithCorrectAspectRatio();
            _playerLoaded = true;

        }
Exemplo n.º 44
0
        public override void ViewDidLoad()
        {
            base.ViewDidLoad();
			
            
            if (((MissionViewModel)ViewModel).Mission.LiveStream)
            {
                chatView.Hidden = false;
                messageField.Hidden = false;
                sendButton.Hidden = false;
                
                firstTitle.Hidden = true;
                secondTitle.Hidden = true;
                imageView.Hidden = true;
                
                var streamingUri = ((MissionViewModel)ViewModel).LiveStreamViewModel.LiveStreamUrl;
                
                _asset = AVAsset.FromUrl(NSUrl.FromString(streamingUri));
                _playerItem = new AVPlayerItem(_asset);
                
                _player = new AVPlayer(_playerItem);

                _playerLayer = AVPlayerLayer.FromPlayer(_player);
                _playerLayer.Frame = new RectangleF(21, 88, 602, 311);
                View.Layer.AddSublayer(_playerLayer);
                _player.Play();
                
                ((MissionViewModel)ViewModel).LiveStreamViewModel.UserName = "******";
                
                chatView.Text = "";
                
                var previousText = string.Empty;
                
                SunnySocket.MessageReceivedAsyncCallback = (string name, string message) =>
                InvokeOnMainThread(() =>
                {
                    if (message != previousText)
                    {
                        chatView.Text = name + " - " + message + "\n" + chatView.Text;
                        chatView.Font = UIFont.FromName("HelveticaNeue-Bold", 15);
                        chatView.TextColor = UIColor.FromRGBA(0.027f, 0.102f, 0.389f, 1.000f);
                        previousText = message;
                    }
                });
                
                messageField.ShouldReturn += (x) =>
                {
                    ((MissionViewModel)ViewModel).LiveStreamViewModel.SendMessageCommand.Execute(null); 
                    return true;
                };
                    
                var set = this.CreateBindingSet<MissionView, MissionViewModel>();
                set.Bind(title).To(vm => vm.Mission.Name);
                set.Bind(messageField).To(vm => vm.LiveStreamViewModel.Message);
                set.Bind(backButton).To("GoBackCommand"); 
                set.Bind(sendButton).To("LiveStreamViewModel.SendMessageCommand"); 
                set.Apply();
                
                messageField.BecomeFirstResponder();
            }
            else
            {
                chatView.Hidden = true;
                messageField.Hidden = true;
                sendButton.Hidden = true;
                
                var imageBorder = new UIButton(UIButtonType.System);
                imageBorder.Frame = new RectangleF(imageView.Frame.X - 1, imageView.Frame.Y - 1, imageView.Frame.Width + 2, imageView.Frame.Height + 2);
                imageBorder.BackgroundColor = UIColor.Clear;
                imageBorder.Layer.BorderColor = UIColor.FromRGBA(0.631f, 0.816f, 0.922f, 1.000f).CGColor;
                imageBorder.Layer.CornerRadius = 4;
                imageBorder.Layer.BorderWidth = 1;
                View.AddSubview(imageBorder);
            
                var webview = new UIWebView();
                webview.Frame = new RectangleF(450, 87, 554, 681);
            
                var webviewBorder = new UIButton(UIButtonType.System);
                webviewBorder.Frame = new RectangleF(webview.Frame.X - 1, webview.Frame.Y - 1, webview.Frame.Width + 2, webview.Frame.Height + 2);
                webviewBorder.BackgroundColor = UIColor.Clear;
                webviewBorder.Layer.BorderColor = UIColor.FromRGBA(0.631f, 0.816f, 0.922f, 1.000f).CGColor;
                webviewBorder.Layer.CornerRadius = 4;
                webviewBorder.Layer.BorderWidth = 1;
                View.AddSubview(webviewBorder);
            
                View.AddSubview(webview);
            
                var newsButton = new UIButton(UIButtonType.System);
                newsButton.Frame = new RectangleF(21, 485, 360, 60);
                newsButton.BackgroundColor = UIColor.Clear;
                newsButton.Layer.BorderColor = UIColor.FromRGBA(0.631f, 0.816f, 0.922f, 1.000f).CGColor;
                newsButton.Layer.CornerRadius = 4;
                newsButton.Layer.BorderWidth = 1;
                View.AddSubview(newsButton);

       
                var notifyButton = new UIButton(UIButtonType.System);
                notifyButton.Frame = new RectangleF(21, 605, 360, 60);
                notifyButton.BackgroundColor = UIColor.Clear;
                notifyButton.Layer.BorderColor = UIColor.FromRGBA(0.631f, 0.816f, 0.922f, 1.000f).CGColor;
                notifyButton.Layer.CornerRadius = 4;
                notifyButton.Layer.BorderWidth = 1;
                View.AddSubview(notifyButton);

                notifyButton.TouchUpInside += (sender, e) =>
                {
                    notifyButton.Enabled = false;
                    new UIAlertView("Thank you", "You'll receive a notification when we go fly fly (or boom boom)", null, "Ok").Show();
                };
            
                var imageViewLoader = new MvxImageViewLoader(() => this.imageView);
                        
                var set = this.CreateBindingSet<MissionView, MissionViewModel>();
                set.Bind(imageViewLoader).To(vm => vm.Mission.ImageUri);
                set.Bind(title).To(vm => vm.Mission.Name);
                set.Bind(newsButton).To("ShowMissionNewsOverviewCommand");
                set.Bind(notifyButton).To("InitPushCommand"); 
                set.Bind(backButton).To("GoBackCommand"); 
                set.Apply();
            
                var html = ((MissionViewModel)ViewModel).Mission.Text;
                webview.LoadHtmlString(html, null);     
            
                webview.ShouldStartLoad += shouldStartLoad; 
            }
                   
        }
        UIImage ImageFor(AVAsset avAsset, double time)
        {
            AVAssetImageGenerator imageGenerator = AVAssetImageGenerator.FromAsset (avAsset);
            imageGenerator.AppliesPreferredTrackTransform = true;

            CMTime actualTime;
            NSError error = null;
            var requestedTime = new CMTime ((long)time, 100);
            using (CGImage posterImage = imageGenerator.CopyCGImageAtTime (requestedTime, out actualTime, out error))
                return UIImage.FromImage (posterImage);
        }