FDK24/メディア/動画.cs

   1 using System;
   2 using System.Collections.Generic;
   3 using System.Diagnostics;
   4 using System.Threading.Tasks;
   5 using FDK.同期;
   6
   7 namespace FDK.メディア
   8 {
   9         /// <remarks>
  10         /// 活性化後の最初の進行描画時に、再生が開始される。
  11         /// </remarks>
  12         public unsafe class 動画 : Activity
  13         {
  14                 public enum 再生状態ID { 未再生, 再生中, 再生終了済み }
  15                 public FDK.同期.RWLock<再生状態ID> 再生状態 { get; } = new RWLock<再生状態ID>( 再生状態ID.未再生 );
  16                 public bool 加算合成 { get; set; } = false;
  17                 public float 不透明度0to1 { get; set; } = 1.0f;
  18                 public bool ループ再生する { get; set; } = false;
  19
  20                 public 動画( string 動画ファイルパス )
  21                 {
  22                         this.動画ファイルパス = FDK.フォルダ.絶対パスに含まれるフォルダ変数を展開して返す( 動画ファイルパス );
  23                 }
  24                 protected override void Onデバイス依存リソースの作成( デバイスリソース dr )
  25                 {
  26                         // todo: デバイスがリサイズされると動画もリセットされてしまう。活性化とコードを分離すること（課題）。
  27
  28                         this.再生状態.Value = 再生状態ID.未再生;
  29                         this.前フレームの時刻 = FDK.カウンタ.QPCTimer.未使用;
  30                         this.ループした際の先頭時刻 = 0;
  31
  32                         string 変数付きファイルパス = フォルダ.絶対パスに含まれるフォルダ変数を展開して返す( this.動画ファイルパス );
  33                         var result = SharpDX.Result.Ok;
  34                         try
  35                         {
  36                                 this.動画の生成に成功した = false;
  37
  38                                 // 動画ファイルパスを基に、SourceReaderEx, MediaType, フレームサイズ, 描画先WICビットマップを準備する。
  39
  40                                 #region " 動画ファイルパスの有効性を確認する。"
  41                                 //-----------------
  42                                 if( string.IsNullOrEmpty( this.動画ファイルパス ) )
  43                                 {
  44                                         Log.ERROR( $"動画ファイルパスが null または空文字列です。[{変数付きファイルパス}]" );
  45                                         return;
  46                                 }
  47                                 if( false == System.IO.File.Exists( this.動画ファイルパス ) )
  48                                 {
  49                                         Log.ERROR( $"動画ファイルが存在しません。[{変数付きファイルパス}]" );
  50                                         return;
  51                                 }
  52                                 //-----------------
  53                                 #endregion
  54                                 #region " 動画のファイルパス（URI扱い）から SourceReaderEx を作成する。"
  55                                 //-----------------
  56                                 try
  57                                 {
  58                                         using( var 属性 = new SharpDX.MediaFoundation.MediaAttributes() )
  59                                         {
  60                                                 // DXVAに対応しているGPUの場合にはそれをデコードに利用するよう指定する。
  61                                                 属性.Set<SharpDX.ComObject>( SharpDX.MediaFoundation.SourceReaderAttributeKeys.D3DManager, dr.DXGIDeviceManager );
  62
  63                                                 // 追加のビデオプロセッシングを有効にする。
  64                                                 属性.Set<bool>( SharpDX.MediaFoundation.SourceReaderAttributeKeys.EnableAdvancedVideoProcessing, true );  // bool だったり
  65
  66                                                 // 追加のビデオプロセッシングを有効にしたら、こちらは無効に。
  67                                                 属性.Set<int>( SharpDX.MediaFoundation.SinkWriterAttributeKeys.ReadwriteDisableConverters, 0 );           // int だったり
  68
  69                                                 // 属性を使って、SourceReaderEx を生成。
  70                                                 using( var sourceReader = new SharpDX.MediaFoundation.SourceReader( this.動画ファイルパス, 属性 ) )
  71                                                 {
  72                                                         this.SourceReaderEx = sourceReader.QueryInterface<SharpDX.MediaFoundation.SourceReaderEx>();
  73                                                 }
  74                                         }
  75                                 }
  76                                 catch( SharpDX.SharpDXException e )
  77                                 {
  78                                         Log.ERROR( $"SourceReaderEx の作成に失敗しました。(0x{e.HResult:x8})[{変数付きファイルパス}]" );
  79                                         result = e.ResultCode;
  80                                         return;
  81                                 }
  82                                 //-----------------
  83                                 #endregion
  84                                 #region " 最初のビデオストリームを選択し、その他のすべてのストリームを非選択にする。"
  85                                 //-----------------
  86                                 try
  87                                 {
  88                                         this.SourceReaderEx.SetStreamSelection( SharpDX.MediaFoundation.SourceReaderIndex.AllStreams, false );
  89                                 }
  90                                 catch( SharpDX.SharpDXException e )
  91                                 {
  92                                         Log.ERROR( $"すべてのストリームの選択解除に失敗しました。(0x{e.HResult:x8})[{変数付きファイルパス}]" );
  93                                         return;
  94                                 }
  95                                 try
  96                                 {
  97                                         this.SourceReaderEx.SetStreamSelection( SharpDX.MediaFoundation.SourceReaderIndex.FirstVideoStream, true );
  98                                 }
  99                                 catch( SharpDX.SharpDXException e )
 100                                 {
 101                                         Log.ERROR( $"最初のビデオストリームの選択に失敗しました。(0x{e.HResult:x8})[{変数付きファイルパス}]" );
 102                                         result = e.ResultCode;
 103                                         return;
 104                                 }
 105                                 //-----------------
 106                                 #endregion
 107                                 #region " ARGB32 フォーマットに合わせたメディアタイプを作成し、SourceReaderEx に登録してデコーダを準備する。"
 108                                 //-----------------
 109                                 try
 110                                 {
 111                                         using( var mediaType = new SharpDX.MediaFoundation.MediaType() )
 112                                         {
 113                                                 // フォーマットを部分メディアタイプの属性に設定。
 114                                                 mediaType.Set<Guid>( SharpDX.MediaFoundation.MediaTypeAttributeKeys.MajorType, SharpDX.MediaFoundation.MediaTypeGuids.Video );
 115                                                 mediaType.Set<Guid>( SharpDX.MediaFoundation.MediaTypeAttributeKeys.Subtype, SharpDX.MediaFoundation.VideoFormatGuids.Argb32 ); // ARGB32 フォーマットで固定。
 116
 117                                                 // 部分メディアタイプを SourceReaderEx にセットする。SourceReaderEx は、必要なデコーダをロードするだろう。
 118                                                 this.SourceReaderEx.SetCurrentMediaType( SharpDX.MediaFoundation.SourceReaderIndex.FirstVideoStream, mediaType );
 119                                         }
 120                                 }
 121                                 catch( SharpDX.SharpDXException e )
 122                                 {
 123                                         Log.ERROR( $"MediaType (Video, ARGB32) の設定または必要なデコーダの読み込みに失敗しました。(0x{e.HResult:x8})[{変数付きファイルパス}]" );
 124                                         result = e.ResultCode;
 125                                         return;
 126                                 }
 127                                 //-----------------
 128                                 #endregion
 129                                 #region " ビデオストリームが選択されていることを再度保証する。"
 130                                 //-----------------
 131                                 try
 132                                 {
 133                                         this.SourceReaderEx.SetStreamSelection( SharpDX.MediaFoundation.SourceReaderIndex.FirstVideoStream, true );
 134                                 }
 135                                 catch( SharpDX.SharpDXException e )
 136                                 {
 137                                         Log.ERROR( $"最初のビデオストリームの選択に失敗しました（MediaType 設定後）。(0x{e.HResult:x8})[{変数付きファイルパス}]" );
 138                                         result = e.ResultCode;
 139                                         return;
 140                                 }
 141                                 //-----------------
 142                                 #endregion
 143                                 #region " デコーダの読み込みにより完成した完全メディアタイプを取得する。"
 144                                 //-----------------
 145                                 try
 146                                 {
 147                                         this.MediaType = this.SourceReaderEx.GetCurrentMediaType( SharpDX.MediaFoundation.SourceReaderIndex.FirstVideoStream );
 148                                 }
 149                                 catch( SharpDX.SharpDXException e )
 150                                 {
 151                                         Log.ERROR( $"完全メディアタイプの取得に失敗しました。(0x{e.HResult:x8})[{変数付きファイルパス}]" );
 152                                         result = e.ResultCode;
 153                                         return;
 154                                 }
 155                                 //-----------------
 156                                 #endregion
 157                                 #region " フレームサイズを取得する。動画の途中でのサイズ変更には対応しない。"
 158                                 //-----------------
 159                                 try
 160                                 {
 161                                         var packedFrameSize = this.MediaType.Get<long>( SharpDX.MediaFoundation.MediaTypeAttributeKeys.FrameSize );
 162                                         this.サイズdpx.Width = (int) ( ( packedFrameSize >> 32 ) & 0xFFFFFFFF );
 163                                         this.サイズdpx.Height = (int) ( ( packedFrameSize ) & 0xFFFFFFFF );
 164                                 }
 165                                 catch( SharpDX.SharpDXException e )
 166                                 {
 167                                         Log.ERROR( $"フレームサイズの取得に失敗しました。(0x{e.HResult:x8})[{変数付きファイルパス}]" );
 168                                         result = e.ResultCode;
 169                                         return;
 170                                 }
 171                                 //-----------------
 172                                 #endregion
 173                                 #region " 描画先WICビットマップを作成する。"
 174                                 //-----------------
 175                                 try
 176                                 {
 177                                         this.WICビットマップ = new SharpDX.WIC.Bitmap(
 178                                                 dr.WicImagingFactory2,
 179                                                 this.サイズdpx.Width,
 180                                                 this.サイズdpx.Height,
 181                                                 SharpDX.WIC.PixelFormat.Format32bppBGR,
 182                                                 SharpDX.WIC.BitmapCreateCacheOption.CacheOnLoad );
 183                                 }
 184                                 catch( SharpDX.SharpDXException e )
 185                                 {
 186                                         Log.ERROR( $"描画先 WIC ビットマップの作成に失敗しました。(0x{e.HResult:x8})[{変数付きファイルパス}]" );
 187                                         result = e.ResultCode;
 188                                         return;
 189                                 }
 190                                 //-----------------
 191                                 #endregion
 192
 193                                 this.動画の生成に成功した = true;
 194                                 Log.Info( $"{Utilities.現在のメソッド名}: 動画を生成しました。[{変数付きファイルパス}]" );
 195
 196                                 #region " デコードの前処理を行う。"
 197                                 //----------------
 198                                 this.デコードキャッシング();
 199                                 Log.Info( $"{Utilities.現在のメソッド名}: 動画のセットアップを行いました。[{変数付きファイルパス}]" );
 200                                 //----------------
 201                                 #endregion
 202
 203                                 // 準備完了。以降は、サンプルを読み込みたいときに、適宜 ReadSample() する。
 204                                 // コールバックを使っていないので、IMFSourceReader::ReadSample() はサンプルが用意できるまでブロックすることに注意。
 205                         }
 206                         finally
 207                         {
 208                                 if( result.Failure )
 209                                         this.全リソースを解放する();
 210
 211                                 // 失敗しても、一応活性化は成功とする。（進行描画はされない。）
 212                         }
 213                 }
 214                 protected override void Onデバイス依存リソースの解放( デバイスリソース dr )
 215                 {
 216                         // todo: デバイスがリサイズされると動画もリセットされてしまう。非活性化とコードを分離すること（課題）。
 217
 218                         // デコード中なら、タスクが終了するまで待つ。
 219                         while( ( this.再生状態.Value == 再生状態ID.再生中 ) && ( this.デコーダ状態.Value == デコーダ状態ID.デコード中 ) )
 220                                 System.Threading.Thread.Sleep( 500 );
 221
 222                         this.全リソースを解放する();
 223                         Log.Info( $"{Utilities.現在のメソッド名}: 動画を解放しました。[{フォルダ.絶対パスに含まれるフォルダ変数を展開して返す( this.動画ファイルパス )}]" );
 224                 }
 225                 public void 進行描画する( デバイスリソース dr, SharpDX.RectangleF 描画先矩形dpx, float 不透明度0to1 = 1.0f, bool ループ再生する = false )
 226                 {
 227                         // Direct2D の行列は、設計単位じゃなく物理単位で計算するので注意。
 228                         var 変換行列2Dpx = SharpDX.Matrix3x2.Identity
 229                                 * SharpDX.Matrix3x2.Scaling( 描画先矩形dpx.Width / this.サイズdpx.Width, 描画先矩形dpx.Height / this.サイズdpx.Height )  // スケーリング。
 230                                 * dr.行列を単位変換するDPXtoPX( SharpDX.Matrix3x2.Translation( 描画先矩形dpx.Left, 描画先矩形dpx.Top ) );  // 平行移動（物理単位）、
 231
 232                         // 描画する。
 233                         this.進行描画する( dr, 変換行列2Dpx );
 234                 }
 235                 public void 進行描画する( デバイスリソース dr, SharpDX.Matrix3x2 変換行列 )
 236                 {
 237                         Debug.Assert( this.活性化している );
 238
 239                         // 活性化でエラーが発生している場合は、何もしない（何も描画しない）。
 240                         if( false == this.動画の生成に成功した )
 241                                 return;
 242
 243                         // 以下、再生状態とデコーダ状態に応じて処理分岐。
 244                         switch( this.再生状態.Value )
 245                         {
 246                                 case 再生状態ID.未再生:
 247                                         // (A) 未再生なら、デコードタスクを開始する。
 248                                         this.再生状態.Value = 再生状態ID.再生中;
 249                                         this.デコードタスクを開始する();
 250                                         break;
 251
 252                                 case 再生状態ID.再生終了済み:
 253                                         // (B) 再生が終了している場合は、何もしない（何も描画しない）。
 254                                         break;
 255
 256                                 case 再生状態ID.再生中:
 257                                         // (C) 再生中なら、D2Dビットマップを描画する。
 258                                         switch( this.デコーダ状態.Value )
 259                                         {
 260                                                 case デコーダ状態ID.デコード中:
 261                                                         // (C-a) タスクが次のサンプルフレームをデコード中なら、現在のD2Dビットマップ（直前のフレーム画像が入ってる）をもう一度描画する。
 262                                                         this.D2Dビットマップを描画する( dr, 変換行列 );
 263                                                         break;
 264
 265                                                 case デコーダ状態ID.完了:
 266                                                         // (C-b) タスクの次のサンプルフレームのデコード処理が完了しているなら、サンプルをD2Dビットマップに転送し、それを描画し、デコードタスクを再び起動する。
 267                                                         this.サンプルをD2Dビットマップに転送する( dr );
 268                                                         this.D2Dビットマップを描画する( dr, 変換行列 );
 269                                                         this.デコードタスクを開始する();
 270                                                         break;
 271
 272                                                 case デコーダ状態ID.スキップ:
 273                                                         // (C-c) タスクの次のサンプルフレームをスキップしたなら、現在のD2Dビットマップ（直前のフレーム画像が入ってる）をもう一度描画し、デコードタスクを再び起動する。
 274                                                         this.D2Dビットマップを描画する( dr, 変換行列 );
 275                                                         this.デコードタスクを開始する();
 276                                                         break;
 277                                         }
 278                                         break;
 279                         }
 280                 }
 281
 282                 private enum デコーダ状態ID { 完了, デコード中, スキップ }
 283                 private readonly FDK.同期.RWLock<デコーダ状態ID> デコーダ状態 = new RWLock<デコーダ状態ID>( デコーダ状態ID.完了 );
 284                 private string 動画ファイルパス = "";
 285                 private bool 動画の生成に成功した = false;    // 活性化時に成功の成否を設定。
 286                 private SharpDX.Result LastSharpDXResult = SharpDX.Result.Ok;
 287                 private SharpDX.MediaFoundation.Sample Sample = null;
 288                 private SharpDX.MediaFoundation.SourceReaderEx SourceReaderEx = null;
 289                 private SharpDX.WIC.Bitmap WICビットマップ = null;    // MediaFoundation は WICBitmap に出力する。
 290                 private SharpDX.Direct2D1.Bitmap D2Dビットマップ = null;  // WICBitmap をこれに転送して D2D に Drawする。
 291                 private SharpDX.MediaFoundation.MediaType MediaType = null;
 292                 private SharpDX.Size2 サイズdpx = new SharpDX.Size2( 1, 1 );  // CopyMemory()で使うので、Size2F じゃなく Size2 を使う。
 293                 private FDK.カウンタ.QPCTimer タイマ = new FDK.カウンタ.QPCTimer();
 294                 private long ループした際の先頭時刻 = 0;
 295                 private long 前フレームの時刻 = FDK.カウンタ.QPCTimer.未使用;  // 未使用 = 先頭のフレームである
 296
 297                 private unsafe void サンプルをD2Dビットマップに転送する( デバイスリソース dr )
 298                 {
 299                         var buffer = (SharpDX.MediaFoundation.MediaBuffer) null;
 300                         var buffer2d2 = (SharpDX.MediaFoundation.Buffer2D2) null;
 301                         try
 302                         {
 303                                 #region " サンプルからサンプルバッファ (MediaBuffer) を取得する。"
 304                                 //-----------------
 305                                 try
 306                                 {
 307                                         buffer = this.Sample.ConvertToContiguousBuffer();
 308                                 }
 309                                 catch( SharpDX.SharpDXException e )
 310                                 {
 311                                         Log.ERROR( $"サンプルバッファの取得に失敗しました。(0x{e.HResult:x8})" );
 312                                         this.LastSharpDXResult = e.ResultCode;
 313                                         return;
 314                                 }
 315                                 //-----------------
 316                                 #endregion
 317                                 #region " サンプルバッファを Buffer2D2 にキャストする。"
 318                                 //-----------------
 319                                 try
 320                                 {
 321                                         buffer2d2 = buffer.QueryInterface<SharpDX.MediaFoundation.Buffer2D2>();
 322                                 }
 323                                 catch( SharpDX.SharpDXException e )
 324                                 {
 325                                         Log.ERROR( $"サンプルバッファから Buffer2D2 へのキャストに失敗しました。(0x{e.HResult:x8})" );
 326                                         this.LastSharpDXResult = e.ResultCode;
 327                                         return;
 328                                 }
 329                                 //-----------------
 330                                 #endregion
 331                                 #region " サンプルバッファをロックする。"
 332                                 //-----------------
 333                                 byte[] scanLine0_bp = new byte[ 8 ];   // 生ポインタが格納される。32bitなら[0～3]、64bitなら[0～7]が有効。（CPUではなく.NETに依存）
 334                                 int pitch = 0;
 335                                 byte[] bufferStart_bp = new byte[ 8 ];  // 生ポインタが格納される。詳細は同上だが、ここでは受け取るだけで何もしない。
 336                                 int bufferLength;
 337                                 try
 338                                 {
 339                                         buffer2d2.Lock2DSize(
 340                                                 SharpDX.MediaFoundation.Buffer2DLockFlags.Read,
 341                                                 scanLine0_bp,
 342                                                 out pitch,
 343                                                 bufferStart_bp,
 344                                                 out bufferLength );
 345                                 }
 346                                 catch( SharpDX.SharpDXException e )
 347                                 {
 348                                         Log.ERROR( $"サンプルバッファのロックに失敗しました。(0x{e.HResult:x8})" );
 349                                         this.LastSharpDXResult = e.ResultCode;
 350                                         return;
 351                                 }
 352                                 //-----------------
 353                                 #endregion
 354                                 try
 355                                 {
 356                                         #region " サンプルバッファのネイティブ先頭アドレスを取得する。"
 357                                         //-----------------
 358                                         byte* scanLine0 = null;
 359                                         try
 360                                         {
 361                                                 scanLine0 = (byte*) this.生ポインタを格納したbyte配列からポインタを取得して返す( scanLine0_bp );
 362                                         }
 363                                         catch( SharpDX.SharpDXException e )
 364                                         {
 365                                                 Log.ERROR( $"サンプルバッファのアドレスの取得に失敗しました。(0x{e.HResult:x8})" );
 366                                                 this.LastSharpDXResult = e.ResultCode;
 367                                                 return;
 368                                         }
 369                                         //-----------------
 370                                         #endregion
 371                                         #region " サンプルバッファから描画先WICビットマップへ、ARGB32 を G8B8R8X8 に変換しながらコピーする。"
 372                                         //-----------------
 373                                         try
 374                                         {
 375                                                 // 描画先WICビットマップをロックする。
 376                                                 using( var bitmapLock = this.WICビットマップ.Lock(
 377                                                         new SharpDX.Rectangle( 0, 0, this.WICビットマップ.Size.Width, this.WICビットマップ.Size.Height ),
 378                                                         SharpDX.WIC.BitmapLockFlags.Write ) )
 379                                                 {
 380                                                         // サンプルバッファからWICビットマップへ、ARGB32 を G8B8R8X8 に変換しながらコピー。
 381                                                         int bitmapStride = bitmapLock.Stride;
 382                                                         byte* src = scanLine0;
 383                                                         byte* dest = (byte*) bitmapLock.Data.DataPointer.ToPointer();
 384
 385                                                         for( int y = 0; y < this.サイズdpx.Height; y++ )
 386                                                         {
 387                                                                 // ARGB32 to G8B8R8X8 ではデータ変換が不要なので、一行を一気にコピー。
 388                                                                 動画.CopyMemory( dest, src, this.サイズdpx.Width * 4 );   // ARGB=4バイト。
 389                                                                 src += pitch;
 390                                                                 dest += bitmapStride;   // bitmapStride は byte 単位
 391                                                         }
 392                                                 }
 393                                         }
 394                                         catch( SharpDX.SharpDXException e )
 395                                         {
 396                                                 Log.ERROR( $"WICビットマップの Lock に失敗しました。(0x{e.HResult:x8})" );
 397                                                 this.LastSharpDXResult = e.ResultCode;
 398                                                 return;
 399                                         }
 400                                         catch( Exception e )
 401                                         {
 402                                                 Log.ERROR( $"サンプルバッファから WIC ビットマップへのデータの転送に失敗しました。(0x{e.HResult:x8})" );
 403                                                 this.LastSharpDXResult = SharpDX.Result.GetResultFromException( e );
 404                                                 return;
 405                                         }
 406                                         //-----------------
 407                                         #endregion
 408                                         #region " 描画先WICビットマップからD2Dビットマップを生成する。 "
 409                                         //-----------------
 410                                         try
 411                                         {
 412                                                 this.D2Dビットマップ?.Dispose();
 413                                                 this.D2Dビットマップ = SharpDX.Direct2D1.Bitmap.FromWicBitmap(
 414                                                         dr.D2DContext1,
 415                                                         this.WICビットマップ );
 416                                         }
 417                                         catch( SharpDX.SharpDXException e )
 418                                         {
 419                                                 Log.ERROR( $"D2Dビットマップの作成に失敗しました。(0x{e.HResult:x8})" );
 420                                                 this.LastSharpDXResult = e.ResultCode;
 421                                                 return;
 422                                         }
 423                                         //-----------------
 424                                         #endregion
 425                                 }
 426                                 finally
 427                                 {
 428                                         #region " サンプルバッファのロックを解除する。"
 429                                         //-----------------
 430                                         buffer2d2.Unlock2D();
 431                                         //-----------------
 432                                         #endregion
 433                                 }
 434                         }
 435                         finally
 436                         {
 437                                 FDK.Utilities.解放する( ref buffer2d2 );
 438                                 FDK.Utilities.解放する( ref buffer );
 439                                 if( this.LastSharpDXResult.Failure )
 440                                 {
 441                                         // 描画に失敗したら、全リソースを解放して再生終了。
 442                                         this.再生状態.Value = 再生状態ID.再生終了済み;
 443                                         this.全リソースを解放する();
 444                                 }
 445                         }
 446                 }
 447                 private void D2Dビットマップを描画する( デバイスリソース dr, SharpDX.Matrix3x2 変換行列2Dpx )
 448                 {
 449                         if( null == this.D2Dビットマップ )
 450                                 return;
 451
 452                         Utilities.D2DBatchDraw( dr.D2DContext1, () => {
 453
 454                                 // 変換行列とブレンドモードを設定する。
 455                                 dr.D2DContext1.Transform = 変換行列2Dpx;
 456                                 dr.D2DContext1.PrimitiveBlend =
 457                                         ( this.加算合成 ) ? SharpDX.Direct2D1.PrimitiveBlend.Add : SharpDX.Direct2D1.PrimitiveBlend.SourceOver;
 458
 459                                 // D2Dビットマップを描画する。
 460                                 dr.D2DContext1.DrawBitmap( this.D2Dビットマップ, this.不透明度0to1, SharpDX.Direct2D1.InterpolationMode.Linear );
 461                         } );
 462                 }
 463                 private void デコードタスクを開始する()
 464                 {
 465                         // 再生中なら、デコードタスクをタスクとして起動する（タスクの完了を待たず、このメソッドはすぐ抜ける）。
 466                         if( this.再生状態.Value == 再生状態ID.再生中 )
 467                         {
 468                                 Task.Run( () => {
 469                                         this.デコードタスク( this.ループ再生する );
 470                                 } );
 471                         }
 472                 }
 473                 private void デコードタスク( bool ループ再生する )
 474                 {
 475                         //  サンプル（フレーム）を１つ取得するタスク。
 476
 477                         this.デコーダ状態.Value = デコーダ状態ID.デコード中;
 478                         this.LastSharpDXResult = SharpDX.Result.Ok;
 479                         try
 480                         {
 481                                 var streamFlags = SharpDX.MediaFoundation.SourceReaderFlags.None;
 482                                 long サンプルの時刻 = 0;
 483
 484                                 #region " SourceReader から次のサンプル（フレーム）を１つ取得する。"
 485                                 //-----------------
 486                                 {
 487                                         int actualStreamIndex = 0;
 488                                         try
 489                                         {
 490                                                 this.Sample?.Dispose();
 491                                                 this.Sample = this.SourceReaderEx.ReadSample(
 492                                                         SharpDX.MediaFoundation.SourceReaderIndex.FirstVideoStream,
 493                                                         SharpDX.MediaFoundation.SourceReaderControlFlags.None,
 494                                                         out actualStreamIndex,
 495                                                         out streamFlags,
 496                                                         out サンプルの時刻 );
 497                                         }
 498                                         catch( SharpDX.SharpDXException e )
 499                                         {
 500                                                 Log.ERROR( $"SourceReaderEx.ReadSample() に失敗しました。(0x{e.HResult:x8})" );
 501                                                 this.LastSharpDXResult = e.ResultCode;
 502                                                 return;
 503                                         }
 504                                 }
 505                                 //-----------------
 506                                 #endregion
 507                                 #region " 取得結果フラグに応じて、必要な処理があれば行なう。"
 508                                 //---------------------------------------------------
 509                                 if( streamFlags.HasFlag( SharpDX.MediaFoundation.SourceReaderFlags.Endofstream ) )  // BOX化コストとか気にしない
 510                                 {
 511                                         #region " ストリーム終了 "
 512                                         //----------------
 513                                         if( ループ再生する )   // メンバじゃなくパラメータのほう。
 514                                         {
 515                                                 // (A) ループ再生する場合
 516                                                 FDK.Log.Info( "動画をループ再生します。" );
 517                                                 this.ループした際の先頭時刻 = this.前フレームの時刻;   // このフラグがセットされるときは、ReadSample() で返されるサンプル時刻は 0 になってるので使えない。
 518                                                 this.SourceReaderEx.SetCurrentPosition( 0 );  // ストリーム再生位置を先頭へ。
 519                                                 this.デコードタスク( ループ再生する ); // 再帰で先頭サンプルを取得して終了。
 520                                                 return;
 521                                         }
 522                                         else
 523                                         {
 524                                                 // (B) ループ再生しない場合
 525                                                 FDK.Log.Info( "動画の再生を終了します。" );
 526                                                 this.再生状態.Value = 再生状態ID.再生終了済み;
 527                                                 this.LastSharpDXResult = SharpDX.Result.Ok; // SharpDX のエラーによる終了じゃないよと。
 528                                                 return;
 529                                         }
 530                                         //----------------
 531                                         #endregion
 532                                 }
 533                                 else if( streamFlags.HasFlag( SharpDX.MediaFoundation.SourceReaderFlags.Newstream ) )
 534                                 {
 535                                         // 未対応。
 536                                 }
 537                                 else if( streamFlags.HasFlag( SharpDX.MediaFoundation.SourceReaderFlags.Nativemediatypechanged ) )
 538                                 {
 539                                         // 未対応。
 540                                 }
 541                                 else if( streamFlags.HasFlag( SharpDX.MediaFoundation.SourceReaderFlags.Currentmediatypechanged ) )
 542                                 {
 543                                         // 未対応。
 544                                 }
 545                                 else if( streamFlags.HasFlag( SharpDX.MediaFoundation.SourceReaderFlags.StreamTick ) )
 546                                 {
 547                                         // 未対応。
 548                                 }
 549                                 else if( streamFlags.HasFlag( SharpDX.MediaFoundation.SourceReaderFlags.AllEffectsremoved ) )
 550                                 {
 551                                         // 未対応。
 552                                 }
 553                                 else if( streamFlags.HasFlag( SharpDX.MediaFoundation.SourceReaderFlags.Error ) )
 554                                 {
 555                                         #region " エラー "
 556                                         //----------------
 557                                         FDK.Log.Info( "エラーが発生したので、動画の再生を終了します。" );
 558                                         this.再生状態.Value = 再生状態ID.再生終了済み;
 559                                         this.LastSharpDXResult = SharpDX.Result.Fail;
 560                                         return;
 561                                         //----------------
 562                                         #endregion
 563                                 }
 564                                 //---------------------------------------------------
 565                                 #endregion
 566                                 #region " 前フレームの時刻を、先頭時刻＋サンプルの時刻 に設定する。"
 567                                 //-----------------
 568                                 if( FDK.カウンタ.QPCTimer.未使用 == 前フレームの時刻 )    // 最初のフレームである場合（ループ時は除く）
 569                                 {
 570                                         // 最初のフレームの取得には時間がかかることが多いので、最初のフレームを取得した場合のみ、タイマをサンプルの時刻にリセットする。
 571                                         this.タイマ.リセットする( サンプルの時刻 );
 572                                 }
 573
 574                                 サンプルの時刻 += this.ループした際の先頭時刻;
 575                                 this.前フレームの時刻 = サンプルの時刻;
 576                                 //-----------------
 577                                 #endregion
 578                                 #region " サンプルの表示時刻までの時刻調整を行う。"
 579                                 //-----------------
 580                                 var 現在時刻 = this.タイマ.現在のリアルタイムカウント100ns単位;
 581                                 if( 現在時刻 > サンプルの時刻 )
 582                                 {
 583                                         // (A) サンプルの時刻が過去である → このサンプルとタスクは捨てる（さっさと次のサンプルへ移る）。
 584                                         this.デコーダ状態.Value = デコーダ状態ID.スキップ;
 585                                         return;
 586                                 }
 587                                 else
 588                                 {
 589                                         // (B) サンプルの時刻が未来である → その時刻を過ぎるまで Sleep する。
 590                                         while( 現在時刻 < サンプルの時刻 )
 591                                         {
 592                                                 System.Threading.Thread.Sleep( 2 );      // 500fps の動画まで対応（理論上（汗
 593                                                 現在時刻 = タイマ.現在のリアルタイムカウント100ns単位;
 594                                         }
 595                                 }
 596                                 //-----------------
 597                                 #endregion
 598                         }
 599                         finally
 600                         {
 601                                 #region " 失敗した、または EndOfStream に達した場合は、Sample を無効化する。"
 602                                 //----------------
 603                                 if( this.LastSharpDXResult.Failure )
 604                                 {
 605                                         FDK.Log.Info( "SharpDX でエラーが発生したので、動画の再生を終了します。" );
 606                                         this.再生状態.Value = 再生状態ID.再生終了済み;
 607                                         FDK.Utilities.解放する( ref this.Sample );
 608                                 }
 609                                 //----------------
 610                                 #endregion
 611
 612                                 this.デコーダ状態.Value = デコーダ状態ID.完了;
 613                         }
 614                 }
 615                 private void デコードキャッシング()
 616                 {
 617                         // 最初のほうのサンプルのデコードには 100～200 ms ほどかかってしまうので、あらかじめ少しデコードしてメモリにキャッシュさせることでこれを緩和する。
 618
 619                         this.デコーダ状態.Value = デコーダ状態ID.デコード中;
 620                         try
 621                         {
 622                                 // 先頭から複数のフレームを読み込む。
 623                                 for( int i = 0; i < 60; i++ )   // 60フレームもあれば、2つめのキーフレームくらいには届くだろう……
 624                                 {
 625                                         #region " SourceReader から次のサンプル（フレーム）を１つ取得しては解放する。"
 626                                         //-----------------
 627                                         var sample = (SharpDX.MediaFoundation.Sample) null;
 628                                         int actualStreamIndex = 0;
 629                                         var streamFlags = SharpDX.MediaFoundation.SourceReaderFlags.None;
 630                                         long サンプルの時刻 = 0;
 631                                         try
 632                                         {
 633                                                 sample = this.SourceReaderEx.ReadSample(
 634                                                         SharpDX.MediaFoundation.SourceReaderIndex.FirstVideoStream,
 635                                                         SharpDX.MediaFoundation.SourceReaderControlFlags.None,
 636                                                         out actualStreamIndex,
 637                                                         out streamFlags,
 638                                                         out サンプルの時刻 );
 639                                         }
 640                                         catch( SharpDX.SharpDXException e )
 641                                         {
 642                                                 Log.ERROR( $"SourceReaderEx.ReadSample() に失敗しました。(0x{e.HResult:x8})" );
 643                                                 this.LastSharpDXResult = e.ResultCode;
 644                                                 return;
 645                                         }
 646                                         finally
 647                                         {
 648                                                 // すぐ解放。
 649                                                 sample?.Dispose();
 650                                         }
 651                                         //-----------------
 652                                         #endregion
 653                                 }
 654                                 // SourceReader を先頭へリセット。
 655                                 this.SourceReaderEx.SetCurrentPosition( 0 );
 656                         }
 657                         finally
 658                         {
 659                                 this.デコーダ状態.Value = デコーダ状態ID.完了;
 660                         }
 661                 }
 662                 private void 全リソースを解放する()
 663                 {
 664                         FDK.Utilities.解放する( ref this.D2Dビットマップ );
 665                         FDK.Utilities.解放する( ref this.WICビットマップ );
 666                         FDK.Utilities.解放する( ref this.Sample );
 667                         FDK.Utilities.解放する( ref this.MediaType );
 668                         FDK.Utilities.解放する( ref this.SourceReaderEx );
 669                 }
 670                 private unsafe void* 生ポインタを格納したbyte配列からポインタを取得して返す( byte[] 生ポインタ )
 671                 {
 672                         if( ( 4 == IntPtr.Size ) && System.BitConverter.IsLittleEndian )
 673                         {
 674                                 // (A) 32bit, リトルエンディアン
 675                                 int 生アドレス32bit = 0;
 676                                 for( int i = 0; i < 4; i++ )
 677                                         生アドレス32bit += ( (int) 生ポインタ[ i ] ) << ( i * 8 );
 678                                 return new IntPtr( 生アドレス32bit ).ToPointer();
 679                         }
 680                         else if( ( 8 == IntPtr.Size ) && System.BitConverter.IsLittleEndian )
 681                         {
 682                                 // (B) 64bit, リトルエンディアン
 683                                 long 生アドレス64bit = 0;
 684                                 for( int i = 0; i < 8; i++ )
 685                                         生アドレス64bit += ( (int) 生ポインタ[ i ] ) << ( i * 8 );
 686                                 return new IntPtr( 生アドレス64bit ).ToPointer();
 687                         }
 688                         else if( ( 4 == IntPtr.Size ) && ( false == System.BitConverter.IsLittleEndian ) )
 689                         {
 690                                 // (C) 32bit, ビッグエンディアン
 691                                 int 生アドレス32bit = 0;
 692                                 for( int i = 0; i < 4; i++ )
 693                                         生アドレス32bit += ( (int) 生ポインタ[ 4 - i ] ) << ( i * 8 );
 694                                 return new IntPtr( 生アドレス32bit ).ToPointer();
 695                         }
 696                         else if( ( 8 == IntPtr.Size ) && ( false == System.BitConverter.IsLittleEndian ) )
 697                         {
 698                                 // (D) 64bit, ビッグエンディアン
 699                                 long 生アドレス64bit = 0;
 700                                 for( int i = 0; i < 8; i++ )
 701                                         生アドレス64bit += ( (int) 生ポインタ[ 8 - i ] ) << ( i * 8 );
 702                                 return new IntPtr( 生アドレス64bit ).ToPointer();
 703                         }
 704
 705                         throw new SharpDX.SharpDXException( SharpDX.Result.NotImplemented, "この .NET アーキテクチャには対応していません。" );
 706                 }
 707
 708                 #region " Win32 API "
 709                 //-----------------
 710                 [System.Runtime.InteropServices.DllImport( "kernel32.dll", SetLastError = true )]
 711                 private static extern unsafe void CopyMemory( void* dst, void* src, int size );
 712                 //-----------------
 713                 #endregion
 714         }
 715 }