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.動画ファイルパス );       // Log出力用。
  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 フォーマットで固定。SourceReaderEx を使わない場合、H264 では NV12 しか選べないので注意。
 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                                 //this.活性化していない = true; --> 失敗しても、一応活性化は成功とする。（進行描画はしない。）
 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
 224                         Log.Info( $"{Utilities.現在のメソッド名}: 動画を解放しました。[{フォルダ.絶対パスに含まれるフォルダ変数を展開して返す( this.動画ファイルパス )}]" );
 225                 }
 226                 public void 進行描画する( デバイスリソース dr, SharpDX.RectangleF 描画先矩形dpx, float 不透明度0to1 = 1.0f, bool ループ再生する = false )
 227                 {
 228                         // Direct2D の行列は、設計単位じゃなく物理単位で計算するので注意。
 229                         var 変換行列2Dpx =
 230                                 dr.拡大行列DPXtoPX // スケーリング(1) DPX → PX
 231                                 * SharpDX.Matrix3x2.Scaling( 描画先矩形dpx.Width / this.サイズdpx.Width, 描画先矩形dpx.Height / this.サイズdpx.Height )  // スケーリング(2)
 232                                 * SharpDX.Matrix3x2.Translation( 描画先矩形dpx.Left * dr.拡大率DPXtoPX横方法, 描画先矩形dpx.Top * dr.拡大率DPXtoPX縦方向 );  // 平行移動（物理単位）、
 233
 234                         // 描画する。
 235                         this.進行描画する( dr, 変換行列2Dpx );
 236                 }
 237                 public void 進行描画する( デバイスリソース dr, SharpDX.Matrix3x2 変換行列 )
 238                 {
 239                         Debug.Assert( this.活性化している );
 240
 241                         // 活性化でエラーが発生している場合は、何もしない（何も描画しない）。
 242                         if( false == this.動画の生成に成功した )
 243                                 return;
 244
 245                         // 以下、再生状態とデコーダ状態に応じて処理分岐。
 246                         switch( this.再生状態.Value )
 247                         {
 248                                 case 再生状態ID.未再生:
 249                                         // (A) 未再生なら、デコードタスクを開始する。
 250                                         this.再生状態.Value = 再生状態ID.再生中;
 251                                         this.デコードタスクを開始する();
 252                                         break;
 253
 254                                 case 再生状態ID.再生終了済み:
 255                                         // (B) 再生が終了している場合は、何もしない（何も描画しない）。
 256                                         break;
 257
 258                                 case 再生状態ID.再生中:
 259                                         // (C) 再生中なら、D2Dビットマップを描画する。
 260                                         switch( this.デコーダ状態.Value )
 261                                         {
 262                                                 case デコーダ状態ID.デコード中:
 263                                                         // (C-a) タスクが次のサンプルフレームをデコード中なら、現在のD2Dビットマップ（直前のフレーム画像が入ってる）をもう一度描画する。
 264                                                         this.D2Dビットマップを描画する( dr, 変換行列 );
 265                                                         break;
 266
 267                                                 case デコーダ状態ID.完了:
 268                                                         // (C-b) タスクの次のサンプルフレームのデコード処理が完了しているなら、サンプルをD2Dビットマップに転送し、それを描画し、デコードタスクを再び起動する。
 269                                                         this.サンプルをD2Dビットマップに転送する( dr );
 270                                                         this.D2Dビットマップを描画する( dr, 変換行列 );
 271                                                         this.デコードタスクを開始する();
 272                                                         break;
 273
 274                                                 case デコーダ状態ID.スキップ:
 275                                                         // (C-c) タスクの次のサンプルフレームをスキップしたなら、現在のD2Dビットマップ（直前のフレーム画像が入ってる）をもう一度描画し、デコードタスクを再び起動する。
 276                                                         this.D2Dビットマップを描画する( dr, 変換行列 );
 277                                                         this.デコードタスクを開始する();
 278                                                         break;
 279                                         }
 280                                         break;
 281                         }
 282                 }
 283
 284                 private enum デコーダ状態ID { 完了, デコード中, スキップ }
 285                 private readonly FDK.同期.RWLock<デコーダ状態ID> デコーダ状態 = new RWLock<デコーダ状態ID>( デコーダ状態ID.完了 );
 286                 private string 動画ファイルパス = "";
 287                 private bool 動画の生成に成功した = false;    // 活性化時に成功の成否を設定。
 288                 private SharpDX.Result LastSharpDXResult = SharpDX.Result.Ok;
 289                 private SharpDX.MediaFoundation.Sample Sample = null;
 290                 private SharpDX.MediaFoundation.SourceReaderEx SourceReaderEx = null;
 291                 private SharpDX.WIC.Bitmap WICビットマップ = null;    // MediaFoundation は WICBitmap に出力する。
 292                 private SharpDX.Direct2D1.Bitmap D2Dビットマップ = null;  // WICBitmap をこれに転送して D2D に Drawする。
 293                 private SharpDX.MediaFoundation.MediaType MediaType = null;
 294                 private SharpDX.Size2 サイズdpx = new SharpDX.Size2( 1, 1 );  // CopyMemory()で使うので、Size2F じゃなく Size2 を使う。
 295                 private FDK.カウンタ.QPCTimer タイマ = new FDK.カウンタ.QPCTimer();
 296                 private long ループした際の先頭時刻 = 0;
 297                 private long 前フレームの時刻 = FDK.カウンタ.QPCTimer.未使用;  // 未使用 = 先頭のフレームである
 298
 299                 private unsafe void サンプルをD2Dビットマップに転送する( デバイスリソース dr )
 300                 {
 301                         var buffer = (SharpDX.MediaFoundation.MediaBuffer) null;
 302                         var buffer2d2 = (SharpDX.MediaFoundation.Buffer2D2) null;
 303                         try
 304                         {
 305                                 #region " サンプルからサンプルバッファ (MediaBuffer) を取得する。"
 306                                 //-----------------
 307                                 try
 308                                 {
 309                                         buffer = this.Sample.ConvertToContiguousBuffer();
 310                                 }
 311                                 catch( SharpDX.SharpDXException e )
 312                                 {
 313                                         Log.ERROR( $"サンプルバッファの取得に失敗しました。(0x{e.HResult:x8})" );
 314                                         this.LastSharpDXResult = e.ResultCode;
 315                                         return;
 316                                 }
 317                                 //-----------------
 318                                 #endregion
 319                                 #region " サンプルバッファを Buffer2D2 にキャストする。"
 320                                 //-----------------
 321                                 try
 322                                 {
 323                                         buffer2d2 = buffer.QueryInterface<SharpDX.MediaFoundation.Buffer2D2>();
 324                                 }
 325                                 catch( SharpDX.SharpDXException e )
 326                                 {
 327                                         Log.ERROR( $"サンプルバッファから Buffer2D2 へのキャストに失敗しました。(0x{e.HResult:x8})" );
 328                                         this.LastSharpDXResult = e.ResultCode;
 329                                         return;
 330                                 }
 331                                 //-----------------
 332                                 #endregion
 333                                 #region " サンプルバッファをロックする。"
 334                                 //-----------------
 335                                 byte[] scanLine0_bp = new byte[ 8 ];    // 「生ポインタ」が格納される。32bitなら[0～3]、64bitなら[0～7]が有効。（CPUではなく.NETに依存）
 336                                 int pitch = 0;
 337                                 byte[] bufferStart_bp = new byte[ 8 ];  // 「生ポインタ」が格納される。こちらは使わない。
 338                                 int bufferLength;
 339                                 try
 340                                 {
 341                                         buffer2d2.Lock2DSize(
 342                                                 SharpDX.MediaFoundation.Buffer2DLockFlags.Read,
 343                                                 scanLine0_bp,
 344                                                 out pitch,
 345                                                 bufferStart_bp,
 346                                                 out bufferLength );
 347                                 }
 348                                 catch( SharpDX.SharpDXException e )
 349                                 {
 350                                         Log.ERROR( $"サンプルバッファのロックに失敗しました。(0x{e.HResult:x8})" );
 351                                         this.LastSharpDXResult = e.ResultCode;
 352                                         return;
 353                                 }
 354                                 //-----------------
 355                                 #endregion
 356                                 try
 357                                 {
 358                                         #region " サンプルバッファのネイティブ先頭アドレスを取得する。"
 359                                         //-----------------
 360                                         byte* scanLine0 = null;
 361                                         try
 362                                         {
 363                                                 scanLine0 = (byte*) this.生ポインタを格納したbyte配列からポインタを取得して返す( scanLine0_bp );
 364                                         }
 365                                         catch( SharpDX.SharpDXException e )
 366                                         {
 367                                                 Log.ERROR( $"サンプルバッファのアドレスの取得に失敗しました。(0x{e.HResult:x8})" );
 368                                                 this.LastSharpDXResult = e.ResultCode;
 369                                                 return;
 370                                         }
 371                                         //-----------------
 372                                         #endregion
 373                                         #region " サンプルバッファから描画先WICビットマップへ、ARGB32 を G8B8R8X8 に変換しながらコピーする。"
 374                                         //-----------------
 375                                         if( null == this.D2Dビットマップ )
 376                                         {
 377                                                 // (A) 初回は WICBitmap 経由で D2Dビットマップを新規生成する。
 378                                                 #region " サンプルバッファから描画先WICビットマップへ、ARGB32 を G8B8R8X8 に変換しながらコピーする。"
 379                                                 //-----------------
 380                                                 try
 381                                                 {
 382                                                         // 描画先WICビットマップをロックする。
 383                                                         using( var bitmapLock = this.WICビットマップ.Lock(
 384                                                                 new SharpDX.Rectangle( 0, 0, this.WICビットマップ.Size.Width, this.WICビットマップ.Size.Height ),
 385                                                                 SharpDX.WIC.BitmapLockFlags.Write ) )
 386                                                         {
 387                                                                 // サンプルバッファからWICビットマップへ、ARGB32 を G8B8R8X8 に変換しながらコピー。
 388                                                                 int bitmapStride = bitmapLock.Stride;
 389                                                                 byte* src = scanLine0;
 390                                                                 byte* dest = (byte*) bitmapLock.Data.DataPointer.ToPointer();
 391
 392                                                                 for( int y = 0; y < this.サイズdpx.Height; y++ )
 393                                                                 {
 394                                                                         // ARGB32 to G8B8R8X8 ではデータ変換が不要なので、一行を一気にコピー。
 395                                                                         動画.CopyMemory( dest, src, this.サイズdpx.Width * 4 );   // ARGB=4バイト。
 396                                                                         src += pitch;
 397                                                                         dest += bitmapStride;   // bitmapStride は byte 単位
 398                                                                 }
 399                                                         }
 400                                                 }
 401                                                 catch( SharpDX.SharpDXException e )
 402                                                 {
 403                                                         Log.ERROR( $"WICビットマップの Lock に失敗しました。(0x{e.HResult:x8})" );
 404                                                         this.LastSharpDXResult = e.ResultCode;
 405                                                         return;
 406                                                 }
 407                                                 catch( Exception e )
 408                                                 {
 409                                                         Log.ERROR( $"サンプルバッファから WIC ビットマップへのデータの転送に失敗しました。(0x{e.HResult:x8})" );
 410                                                         this.LastSharpDXResult = SharpDX.Result.GetResultFromException( e );
 411                                                         return;
 412                                                 }
 413                                                 //-----------------
 414                                                 #endregion
 415                                                 #region " 描画先WICビットマップからD2Dビットマップを生成する。 "
 416                                                 //-----------------
 417                                                 try
 418                                                 {
 419                                                         this.D2Dビットマップ = SharpDX.Direct2D1.Bitmap.FromWicBitmap(
 420                                                                 dr.D2DContext1,
 421                                                                 this.WICビットマップ );
 422                                                 }
 423                                                 catch( SharpDX.SharpDXException e )
 424                                                 {
 425                                                         Log.ERROR( $"D2Dビットマップの作成に失敗しました。(0x{e.HResult:x8})" );
 426                                                         this.LastSharpDXResult = e.ResultCode;
 427                                                         return;
 428                                                 }
 429                                                 //-----------------
 430                                                 #endregion
 431                                         }
 432                                         else
 433                                         {
 434                                                 // (B) ２回目以降は直接 D2Dビットマップへコピーする。
 435                                                 this.D2Dビットマップ.CopyFromMemory( new IntPtr( scanLine0 ), pitch );
 436                                         }
 437                                         //-----------------
 438                                         #endregion
 439                                 }
 440                                 finally
 441                                 {
 442                                         #region " サンプルバッファのロックを解除する。"
 443                                         //-----------------
 444                                         buffer2d2.Unlock2D();
 445                                         //-----------------
 446                                         #endregion
 447                                 }
 448                         }
 449                         finally
 450                         {
 451                                 FDK.Utilities.解放する( ref buffer2d2 );
 452                                 FDK.Utilities.解放する( ref buffer );
 453                                 if( this.LastSharpDXResult.Failure )
 454                                 {
 455                                         // 描画に失敗したら、全リソースを解放して再生終了。
 456                                         this.再生状態.Value = 再生状態ID.再生終了済み;
 457                                         this.全リソースを解放する();
 458                                 }
 459                         }
 460                 }
 461                 private void D2Dビットマップを描画する( デバイスリソース dr, SharpDX.Matrix3x2 変換行列2Dpx )
 462                 {
 463                         if( null == this.D2Dビットマップ )
 464                                 return;
 465
 466                         Utilities.D2DBatchDraw( dr.D2DContext1, () => {
 467
 468                                 // 変換行列とブレンドモードを設定する。
 469                                 dr.D2DContext1.Transform = 変換行列2Dpx;
 470                                 dr.D2DContext1.PrimitiveBlend = ( this.加算合成 ) ? SharpDX.Direct2D1.PrimitiveBlend.Add : SharpDX.Direct2D1.PrimitiveBlend.SourceOver;
 471
 472                                 // D2Dビットマップを描画する。
 473                                 dr.D2DContext1.DrawBitmap( this.D2Dビットマップ, this.不透明度0to1, SharpDX.Direct2D1.InterpolationMode.Linear );
 474                         } );
 475                 }
 476                 private void デコードタスクを開始する()
 477                 {
 478                         // 再生中なら、デコードタスクをタスクとして起動する（タスクの完了を待たず、このメソッドはすぐ抜ける）。
 479                         if( this.再生状態.Value == 再生状態ID.再生中 )
 480                         {
 481                                 Task.Run( () => {
 482                                         this.デコードタスク( this.ループ再生する );
 483                                 } );
 484                         }
 485                 }
 486                 private void デコードタスク( bool ループ再生する )
 487                 {
 488                         //  サンプル（フレーム）を１つ取得するタスク。
 489
 490                         this.デコーダ状態.Value = デコーダ状態ID.デコード中;
 491                         this.LastSharpDXResult = SharpDX.Result.Ok;
 492                         try
 493                         {
 494                                 var ストリームフラグ = SharpDX.MediaFoundation.SourceReaderFlags.None;
 495                                 long サンプルの時刻 = 0;
 496
 497                                 #region " SourceReader から次のサンプル（フレーム）を１つ取得する。"
 498                                 //-----------------
 499                                 {
 500                                         int 実ストリーム番号 = 0;
 501                                         try
 502                                         {
 503                                                 this.Sample?.Dispose();
 504                                                 this.Sample = this.SourceReaderEx.ReadSample(
 505                                                         SharpDX.MediaFoundation.SourceReaderIndex.FirstVideoStream,
 506                                                         SharpDX.MediaFoundation.SourceReaderControlFlags.None,
 507                                                         out 実ストリーム番号,
 508                                                         out ストリームフラグ,
 509                                                         out サンプルの時刻 );
 510                                         }
 511                                         catch( SharpDX.SharpDXException e )
 512                                         {
 513                                                 Log.ERROR( $"SourceReaderEx.ReadSample() に失敗しました。(0x{e.HResult:x8})" );
 514                                                 this.LastSharpDXResult = e.ResultCode;
 515                                                 return;
 516                                         }
 517                                 }
 518                                 //-----------------
 519                                 #endregion
 520                                 #region " 取得結果フラグに応じて、必要な処理があれば行なう。"
 521                                 //---------------------------------------------------
 522                                 if( ストリームフラグ.HasFlag( SharpDX.MediaFoundation.SourceReaderFlags.Endofstream ) )  // BOX化コストとか気にしない
 523                                 {
 524                                         #region " ストリーム終了 "
 525                                         //----------------
 526                                         if( ループ再生する )   // メンバじゃなくパラメータのほう。
 527                                         {
 528                                                 // (A) ループ再生する場合
 529                                                 FDK.Log.Info( "動画をループ再生します。" );
 530                                                 this.ループした際の先頭時刻 = this.前フレームの時刻;   // このフラグがセットされるときは、ReadSample() で返されるサンプル時刻は 0 になってるので使えない。
 531                                                 this.SourceReaderEx.SetCurrentPosition( 0 );  // ストリーム再生位置を先頭へ。
 532                                                 this.デコードタスク( ループ再生する ); // 再帰で先頭サンプルを取得して終了。
 533                                                 return;
 534                                         }
 535                                         else
 536                                         {
 537                                                 // (B) ループ再生しない場合
 538                                                 FDK.Log.Info( "動画の再生を終了します。" );
 539                                                 this.再生状態.Value = 再生状態ID.再生終了済み;
 540                                                 this.LastSharpDXResult = SharpDX.Result.Ok; // SharpDX のエラーによる終了じゃないよと。
 541                                                 return;
 542                                         }
 543                                         //----------------
 544                                         #endregion
 545                                 }
 546                                 else if( ストリームフラグ.HasFlag( SharpDX.MediaFoundation.SourceReaderFlags.Newstream ) )
 547                                 {
 548                                         // 未対応。
 549                                 }
 550                                 else if( ストリームフラグ.HasFlag( SharpDX.MediaFoundation.SourceReaderFlags.Nativemediatypechanged ) )
 551                                 {
 552                                         // 未対応。
 553                                 }
 554                                 else if( ストリームフラグ.HasFlag( SharpDX.MediaFoundation.SourceReaderFlags.Currentmediatypechanged ) )
 555                                 {
 556                                         // 未対応。
 557                                 }
 558                                 else if( ストリームフラグ.HasFlag( SharpDX.MediaFoundation.SourceReaderFlags.StreamTick ) )
 559                                 {
 560                                         // 未対応。
 561                                 }
 562                                 else if( ストリームフラグ.HasFlag( SharpDX.MediaFoundation.SourceReaderFlags.AllEffectsremoved ) )
 563                                 {
 564                                         // 未対応。
 565                                 }
 566                                 else if( ストリームフラグ.HasFlag( SharpDX.MediaFoundation.SourceReaderFlags.Error ) )
 567                                 {
 568                                         #region " エラー "
 569                                         //----------------
 570                                         FDK.Log.Info( "エラーが発生したので、動画の再生を終了します。" );
 571                                         this.再生状態.Value = 再生状態ID.再生終了済み;
 572                                         this.LastSharpDXResult = SharpDX.Result.Fail;
 573                                         return;
 574                                         //----------------
 575                                         #endregion
 576                                 }
 577                                 //---------------------------------------------------
 578                                 #endregion
 579                                 #region " 前フレームの時刻を、先頭時刻＋サンプルの時刻 に設定する。"
 580                                 //-----------------
 581                                 if( FDK.カウンタ.QPCTimer.未使用 == 前フレームの時刻 )    // 最初のフレームである場合（ループ時は除く）
 582                                 {
 583                                         // 最初のフレームの取得には時間がかかることが多いので、最初のフレームを取得した場合のみ、タイマをサンプルの時刻にリセットする。
 584                                         this.タイマ.リセットする( サンプルの時刻 );
 585                                 }
 586
 587                                 サンプルの時刻 += this.ループした際の先頭時刻;
 588                                 this.前フレームの時刻 = サンプルの時刻;
 589                                 //-----------------
 590                                 #endregion
 591                                 #region " サンプルの表示時刻までの時刻調整を行う。"
 592                                 //-----------------
 593                                 var 現在時刻 = this.タイマ.現在のリアルタイムカウント100ns単位;
 594                                 if( 現在時刻 > サンプルの時刻 )
 595                                 {
 596                                         // (A) サンプルの時刻が過去である → このサンプルとタスクは捨てる（さっさと次のサンプルへ移る）。
 597                                         this.デコーダ状態.Value = デコーダ状態ID.スキップ;
 598                                         return;
 599                                 }
 600                                 else
 601                                 {
 602                                         // (B) サンプルの時刻が未来である → その時刻を過ぎるまで Sleep する。
 603                                         while( 現在時刻 < サンプルの時刻 )
 604                                         {
 605                                                 System.Threading.Thread.Sleep( 2 );      // 500fps の動画まで対応（理論上（汗
 606                                                 現在時刻 = タイマ.現在のリアルタイムカウント100ns単位;
 607                                         }
 608                                 }
 609                                 //-----------------
 610                                 #endregion
 611                         }
 612                         finally
 613                         {
 614                                 #region " 失敗した、または EndOfStream に達した場合は、Sample を無効化する。"
 615                                 //----------------
 616                                 if( this.LastSharpDXResult.Failure )
 617                                 {
 618                                         FDK.Log.Info( "SharpDX でエラーが発生したので、動画の再生を終了します。" );
 619                                         this.再生状態.Value = 再生状態ID.再生終了済み;
 620                                         FDK.Utilities.解放する( ref this.Sample );
 621                                 }
 622                                 //----------------
 623                                 #endregion
 624
 625                                 this.デコーダ状態.Value = デコーダ状態ID.完了;
 626                         }
 627                 }
 628                 private void デコードキャッシング()
 629                 {
 630                         // 最初のほうのサンプルのデコードには 100～200 ms ほどかかってしまうので、あらかじめ少しデコードしてメモリにキャッシュさせることでこれを緩和する。
 631
 632                         this.デコーダ状態.Value = デコーダ状態ID.デコード中;
 633                         try
 634                         {
 635                                 // 先頭から複数のフレームを読み込む。
 636                                 for( int i = 0; i < 60; i++ )   // 60フレームもあれば、2つめのキーフレームくらいには届くだろう……
 637                                 {
 638                                         #region " SourceReader から次のサンプル（フレーム）を１つ取得しては解放する。"
 639                                         //-----------------
 640                                         var sample = (SharpDX.MediaFoundation.Sample) null;
 641                                         int actualStreamIndex = 0;
 642                                         var streamFlags = SharpDX.MediaFoundation.SourceReaderFlags.None;
 643                                         long サンプルの時刻 = 0;
 644                                         try
 645                                         {
 646                                                 sample = this.SourceReaderEx.ReadSample(
 647                                                         SharpDX.MediaFoundation.SourceReaderIndex.FirstVideoStream,
 648                                                         SharpDX.MediaFoundation.SourceReaderControlFlags.None,
 649                                                         out actualStreamIndex,
 650                                                         out streamFlags,
 651                                                         out サンプルの時刻 );
 652                                         }
 653                                         catch( SharpDX.SharpDXException e )
 654                                         {
 655                                                 Log.ERROR( $"SourceReaderEx.ReadSample() に失敗しました。(0x{e.HResult:x8})" );
 656                                                 this.LastSharpDXResult = e.ResultCode;
 657                                                 return;
 658                                         }
 659                                         finally
 660                                         {
 661                                                 // すぐ解放。
 662                                                 sample?.Dispose();
 663                                         }
 664                                         //-----------------
 665                                         #endregion
 666                                 }
 667                                 // SourceReader を先頭へリセット。
 668                                 this.SourceReaderEx.SetCurrentPosition( 0 );
 669                         }
 670                         finally
 671                         {
 672                                 this.デコーダ状態.Value = デコーダ状態ID.完了;
 673                         }
 674                 }
 675                 private void 全リソースを解放する()
 676                 {
 677                         FDK.Utilities.解放する( ref this.D2Dビットマップ );
 678                         FDK.Utilities.解放する( ref this.WICビットマップ );
 679                         FDK.Utilities.解放する( ref this.Sample );
 680                         FDK.Utilities.解放する( ref this.MediaType );
 681                         FDK.Utilities.解放する( ref this.SourceReaderEx );
 682                 }
 683                 private unsafe void* 生ポインタを格納したbyte配列からポインタを取得して返す( byte[] 生ポインタ )
 684                 {
 685                         if( ( 4 == IntPtr.Size ) && System.BitConverter.IsLittleEndian )
 686                         {
 687                                 // (A) 32bit, リトルエンディアン
 688                                 int 生アドレス32bit = 0;
 689                                 for( int i = 0; i < 4; i++ )
 690                                         生アドレス32bit += ( (int) 生ポインタ[ i ] ) << ( i * 8 );
 691                                 return new IntPtr( 生アドレス32bit ).ToPointer();
 692                         }
 693                         else if( ( 8 == IntPtr.Size ) && System.BitConverter.IsLittleEndian )
 694                         {
 695                                 // (B) 64bit, リトルエンディアン
 696                                 long 生アドレス64bit = 0;
 697                                 for( int i = 0; i < 8; i++ )
 698                                         生アドレス64bit += ( (int) 生ポインタ[ i ] ) << ( i * 8 );
 699                                 return new IntPtr( 生アドレス64bit ).ToPointer();
 700                         }
 701                         else if( ( 4 == IntPtr.Size ) && ( false == System.BitConverter.IsLittleEndian ) )
 702                         {
 703                                 // (C) 32bit, ビッグエンディアン
 704                                 int 生アドレス32bit = 0;
 705                                 for( int i = 0; i < 4; i++ )
 706                                         生アドレス32bit += ( (int) 生ポインタ[ 4 - i ] ) << ( i * 8 );
 707                                 return new IntPtr( 生アドレス32bit ).ToPointer();
 708                         }
 709                         else if( ( 8 == IntPtr.Size ) && ( false == System.BitConverter.IsLittleEndian ) )
 710                         {
 711                                 // (D) 64bit, ビッグエンディアン
 712                                 long 生アドレス64bit = 0;
 713                                 for( int i = 0; i < 8; i++ )
 714                                         生アドレス64bit += ( (int) 生ポインタ[ 8 - i ] ) << ( i * 8 );
 715                                 return new IntPtr( 生アドレス64bit ).ToPointer();
 716                         }
 717
 718                         throw new SharpDX.SharpDXException( SharpDX.Result.NotImplemented, "この .NET アーキテクチャには対応していません。" );
 719                 }
 720
 721                 #region " Win32 API "
 722                 //-----------------
 723                 [System.Runtime.InteropServices.DllImport( "kernel32.dll", SetLastError = true )]
 724                 private static extern unsafe void CopyMemory( void* dst, void* src, int size );
 725                 //-----------------
 726                 #endregion
 727         }
 728 }