FDK24/メディア/動画.cs

   1 using System;
   2 using System.Collections.Concurrent;
   3 using System.Collections.Generic;
   4 using System.Diagnostics;
   5 using System.Linq;
   6
   7 namespace FDK.メディア
   8 {
   9         public class 動画 : FDK.Activity
  10         {
  11                 public string 動画ファイルパス
  12                 {
  13                         get;
  14                         protected set;
  15                 } = null;
  16
  17                 public SharpDX.Size2F サイズdpx
  18                 {
  19                         get;
  20                         protected set;
  21                 }
  22
  23                 public double 長さsec
  24                 {
  25                         get;
  26                         protected set;
  27                 } = 0.0;
  28
  29                 public bool 加算合成
  30                 {
  31                         get;
  32                         set;
  33                 } = false;
  34
  35                 /// <summary>
  36                 ///             0:透明 ～ 1:不透明
  37                 /// </summary>
  38                 public float 不透明度
  39                 {
  40                         get;
  41                         set;
  42                 } = 1.0f;
  43
  44                 public 動画( string 動画ファイルパス, int キューのサイズ = 16 )
  45                 {
  46                         this.動画ファイルパス = FDK.フォルダ.絶対パスに含まれるフォルダ変数を展開して返す( 動画ファイルパス );
  47                         this._キューのサイズ = キューのサイズ;
  48                 }
  49
  50                 public void 再生を開始する( double 開始位置sec = 0.0, bool ループ再生する = false )
  51                 {
  52                         this._ループ再生する = ループ再生する;
  53
  54                         // タスクを起動する。
  55                         this._デコードタスク = System.Threading.Tasks.Task.Factory.StartNew( this._デコードタスクエントリ, (object) 開始位置sec );
  56                         this._デコードタスク起動完了.WaitOne();
  57                 }
  58
  59                 public void 進行描画する( デバイスリソース dr, SharpDX.RectangleF 描画先矩形dpx, float 不透明度0to1 = 1.0f )
  60                 {
  61                         // Direct2D の行列は、設計単位じゃなく物理単位で計算するので注意。
  62                         var 変換行列2Dpx =
  63                                 dr.拡大行列DPXtoPX // スケーリング(1) DPX → PX
  64                                 * SharpDX.Matrix3x2.Scaling( 描画先矩形dpx.Width / this.サイズdpx.Width, 描画先矩形dpx.Height / this.サイズdpx.Height )  // スケーリング(2)
  65                                 * SharpDX.Matrix3x2.Translation( 描画先矩形dpx.Left * dr.拡大率DPXtoPX横方向, 描画先矩形dpx.Top * dr.拡大率DPXtoPX縦方向 );  // 平行移動（物理単位）、
  66
  67                         this.進行描画する( dr, 変換行列2Dpx, 不透明度0to1 );
  68                 }
  69
  70                 public void 進行描画する( デバイスリソース dr, SharpDX.Matrix3x2 変換行列, float 不透明度0to1 = 1.0f )
  71                 {
  72                         #region " 条件チェック。"
  73                         //----------------
  74                         if( null == this._デコードタスク ||      // 再生をまだ開始していないか、あるいはすでに再生を完了してデコードタスクを終了済みである。
  75                                 null == this._SourceReaderEx ||         // 動画の準備に失敗した。
  76                                 null == this._MediaType ||                      // 同上
  77                                 null == this._WicBitmap )                       // 同上
  78                         {
  79                                 return;
  80                         }
  81                         //----------------
  82                         #endregion
  83
  84                         Action<FrameQueueItem> 次のフレームを表示する = ( frame ) => {
  85                                 this._次のフレームを取り出す( out frame );
  86                                 this._最後に表示したフレーム?.Dispose();
  87                                 this._最後に表示したフレーム = frame;
  88                                 this._D2DBitmapを描画する( dr, 変換行列, frame.D2DBitmap, 不透明度0to1 );
  89                         };
  90                         Action 前のフレームを表示する = () => {
  91                                 this._D2DBitmapを描画する( dr, 変換行列, this._最後に表示したフレーム?.D2DBitmap, 不透明度0to1 );
  92                         };
  93
  94                         var フレーム = (FrameQueueItem) null;
  95                         this._次のフレームを確認する( out フレーム );
  96
  97
  98                         if( null != フレーム )  // 次のフレームがある。
  99                         {
 100                                 // (A) 次のフレームが前のフレームより過去 → ループしたので、タイマをリセットする。
 101                                 if( ( null != this._最後に表示したフレーム ) &&
 102                                         ( フレーム.表示時刻sec < this._最後に表示したフレーム.表示時刻sec ) )
 103                                 {
 104                                         this._再生タイマ.Value.リセットする( FDK.カウンタ.QPCTimer.秒をカウントに変換して返す( フレーム.表示時刻sec ) );
 105                                         次のフレームを表示する( フレーム );
 106                                 }
 107
 108                                 // (B) 次のフレームの表示時刻に達した。
 109                                 else if( フレーム.表示時刻sec <= this._再生タイマ.Value.現在のリアルタイムカウントsec )
 110                                 {
 111                                         次のフレームを表示する( フレーム );
 112                                 }
 113
 114                                 // (C) 次のフレームの表示時刻にはまだ達していない。
 115                                 else
 116                                 {
 117                                         前のフレームを表示する();
 118                                 }
 119                         }
 120
 121                         // (D) デコードが追い付いてない、またはループせず再生が終わっている。
 122                         else
 123                         {
 124                                 // 何も表示しない → 真っ黒画像。デコードが追い付いてないなら点滅するだろう。
 125                         }
 126                 }
 127
 128                 protected override void On活性化( デバイスリソース dr )
 129                 {
 130                         this._デコードタスク = null;  // タスクが起動していないときは null であることを保証する。
 131                         this._デコードタスク起動完了 = new System.Threading.AutoResetEvent( false );
 132                         this._キューが空いた = new System.Threading.ManualResetEvent( true );
 133                         this._デコードタスクを終了せよ = new System.Threading.AutoResetEvent( false );
 134                         this._再生タイマ.Value = new カウンタ.QPCTimer();
 135                 }
 136
 137                 protected override void On非活性化( デバイスリソース dr )
 138                 {
 139                         this._キューが空いた.Close();
 140                         this._デコードタスクを終了せよ.Close();
 141                 }
 142
 143                 protected override void Onデバイス依存リソースの作成( デバイスリソース dr )
 144                 {
 145                         FDK.Log.BeginInfo( $"{FDK.Utilities.現在のメソッド名}" );
 146                         try
 147                         {
 148                                 this._デコードタスク用D2DDeviceContext参照 = dr.D2DContext1;
 149                                 this._フレームキュー = new ConcurrentQueue<FrameQueueItem>();
 150                                 this._最後に表示したフレーム = null;
 151
 152                                 // 動画ファイルから、SourceReaderEx, MediaType, WicBitmap を生成する。
 153
 154                                 string 変数付きファイルパス = フォルダ.絶対パスに含まれるフォルダ変数を展開して返す( 動画ファイルパス );   // Log出力用。
 155
 156                                 #region " 動画ファイルパスの有効性を確認する。"
 157                                 //-----------------
 158                                 if( string.IsNullOrEmpty( 動画ファイルパス ) )
 159                                 {
 160                                         Log.ERROR( $"動画ファイルパスが null または空文字列です。[{変数付きファイルパス}]" );
 161                                         return;
 162                                 }
 163                                 if( false == System.IO.File.Exists( 動画ファイルパス ) )
 164                                 {
 165                                         Log.ERROR( $"動画ファイルが存在しません。[{変数付きファイルパス}]" );
 166                                         return;
 167                                 }
 168                                 //-----------------
 169                                 #endregion
 170                                 #region " SourceReaderEx を生成する。"
 171                                 //-----------------
 172                                 try
 173                                 {
 174                                         using( var 属性 = new SharpDX.MediaFoundation.MediaAttributes() )
 175                                         {
 176                                                 // DXVAに対応しているGPUの場合には、それをデコードに利用するよう指定する。
 177                                                 属性.Set<SharpDX.ComObject>( SharpDX.MediaFoundation.SourceReaderAttributeKeys.D3DManager, dr.DXGIDeviceManager );
 178
 179                                                 // 追加のビデオプロセッシングを有効にする。
 180                                                 属性.Set<bool>( SharpDX.MediaFoundation.SourceReaderAttributeKeys.EnableAdvancedVideoProcessing, true );  // 真偽値が bool だったり
 181
 182                                                 // 追加のビデオプロセッシングを有効にしたら、こちらは無効に。
 183                                                 属性.Set<int>( SharpDX.MediaFoundation.SinkWriterAttributeKeys.ReadwriteDisableConverters, 0 );           // int だったり
 184
 185                                                 // 属性を使って、SourceReaderEx を生成。
 186                                                 using( var sourceReader = new SharpDX.MediaFoundation.SourceReader( 動画ファイルパス, 属性 ) )    // パスは URI 扱い
 187                                                 {
 188                                                         this._SourceReaderEx = sourceReader.QueryInterface<SharpDX.MediaFoundation.SourceReaderEx>();
 189                                                 }
 190                                         }
 191                                 }
 192                                 catch( SharpDX.SharpDXException e )
 193                                 {
 194                                         Log.ERROR( $"SourceReaderEx の作成に失敗しました。(0x{e.HResult:x8})[{変数付きファイルパス}]" );
 195                                         throw;
 196                                 }
 197                                 //-----------------
 198                                 #endregion
 199                                 #region " 最初のビデオストリームを選択し、その他のすべてのストリームを非選択にする。"
 200                                 //-----------------
 201                                 try
 202                                 {
 203                                         this._SourceReaderEx.SetStreamSelection( SharpDX.MediaFoundation.SourceReaderIndex.AllStreams, false );
 204                                         this._SourceReaderEx.SetStreamSelection( SharpDX.MediaFoundation.SourceReaderIndex.FirstVideoStream, true );
 205                                 }
 206                                 catch( SharpDX.SharpDXException e )
 207                                 {
 208                                         Log.ERROR( $"ストリームの選択に失敗しました。(0x{e.HResult:x8})[{変数付きファイルパス}]" );
 209                                         throw;
 210                                 }
 211                                 //-----------------
 212                                 #endregion
 213                                 #region " 部分 MediaType を作成し、SourceReaderEx に登録する。"
 214                                 //-----------------
 215                                 try
 216                                 {
 217                                         using( var mediaType = new SharpDX.MediaFoundation.MediaType() )
 218                                         {
 219                                                 // フォーマットは ARGB32 で固定とする。（SourceReaderEx を使わない場合、H264 では ARGB32 が選べないので注意。）
 220                                                 mediaType.Set<Guid>( SharpDX.MediaFoundation.MediaTypeAttributeKeys.MajorType, SharpDX.MediaFoundation.MediaTypeGuids.Video );
 221                                                 mediaType.Set<Guid>( SharpDX.MediaFoundation.MediaTypeAttributeKeys.Subtype, SharpDX.MediaFoundation.VideoFormatGuids.Argb32 );
 222
 223                                                 // 部分メディアタイプを SourceReaderEx にセットする。SourceReaderEx は、必要なデコーダをロードするだろう。
 224                                                 this._SourceReaderEx.SetCurrentMediaType( SharpDX.MediaFoundation.SourceReaderIndex.FirstVideoStream, mediaType );
 225                                         }
 226                                 }
 227                                 catch( SharpDX.SharpDXException e )
 228                                 {
 229                                         Log.ERROR( $"MediaType (Video, ARGB32) の設定または必要なデコーダの読み込みに失敗しました。(0x{e.HResult:x8})[{変数付きファイルパス}]" );
 230                                         throw;
 231                                 }
 232                                 //-----------------
 233                                 #endregion
 234                                 #region " ビデオストリームが選択されていることを再度保証する。"
 235                                 //-----------------
 236                                 try
 237                                 {
 238                                         this._SourceReaderEx.SetStreamSelection( SharpDX.MediaFoundation.SourceReaderIndex.FirstVideoStream, true );
 239                                 }
 240                                 catch( SharpDX.SharpDXException e )
 241                                 {
 242                                         Log.ERROR( $"最初のビデオストリームの選択に失敗しました（MediaType 設定後）。(0x{e.HResult:x8})[{変数付きファイルパス}]" );
 243                                         throw;
 244                                 }
 245                                 //-----------------
 246                                 #endregion
 247                                 #region " 完全 MediaType と動画の情報を取得する。"
 248                                 //-----------------
 249                                 try
 250                                 {
 251                                         this._MediaType = this._SourceReaderEx.GetCurrentMediaType( SharpDX.MediaFoundation.SourceReaderIndex.FirstVideoStream );
 252                                 }
 253                                 catch( SharpDX.SharpDXException e )
 254                                 {
 255                                         Log.ERROR( $"完全メディアタイプの取得に失敗しました。(0x{e.HResult:x8})[{変数付きファイルパス}]" );
 256                                         throw;
 257                                 }
 258
 259                                 // フレームサイズを取得する。
 260                                 try
 261                                 {
 262                                         // 動画の途中でのサイズ変更には対応しない。
 263                                         var packedFrameSize = this._MediaType.Get<long>( SharpDX.MediaFoundation.MediaTypeAttributeKeys.FrameSize );
 264                                         this.サイズdpx = new SharpDX.Size2F( ( packedFrameSize >> 32 ) & 0xFFFFFFFF, ( packedFrameSize ) & 0xFFFFFFFF );
 265                                 }
 266                                 catch( SharpDX.SharpDXException e )
 267                                 {
 268                                         Log.ERROR( $"フレームサイズの取得に失敗しました。(0x{e.HResult:x8})[{変数付きファイルパス}]" );
 269                                         throw;
 270                                 }
 271
 272                                 // 動画の長さを取得する。
 273                                 try
 274                                 {
 275                                         this.長さsec = this._SourceReaderEx.GetPresentationAttribute(
 276                                                 SharpDX.MediaFoundation.SourceReaderIndex.MediaSource,
 277                                                 SharpDX.MediaFoundation.PresentationDescriptionAttributeKeys.Duration
 278                                                 ) / ( 1000.0 * 1000.0 * 10.0 );
 279                                 }
 280                                 catch( SharpDX.SharpDXException e )
 281                                 {
 282                                         Log.ERROR( $"動画の長さの取得に失敗しました。(0x{e.HResult:x8})[{変数付きファイルパス}]" );
 283                                         throw;
 284                                 }
 285                                 //-----------------
 286                                 #endregion
 287                                 #region " 描画先となる WicBitmap を作成する。"
 288                                 //-----------------
 289                                 try
 290                                 {
 291                                         this._WicBitmap = new SharpDX.WIC.Bitmap(
 292                                                 dr.WicImagingFactory2,
 293                                                 (int) this.サイズdpx.Width,
 294                                                 (int) this.サイズdpx.Height,
 295                                                 SharpDX.WIC.PixelFormat.Format32bppBGR,
 296                                                 SharpDX.WIC.BitmapCreateCacheOption.CacheOnLoad );
 297                                 }
 298                                 catch( SharpDX.SharpDXException e )
 299                                 {
 300                                         Log.ERROR( $"描画先となる WICビットマップの作成に失敗しました。(0x{e.HResult:x8})[{変数付きファイルパス}]" );
 301                                         throw;
 302                                 }
 303                                 //-----------------
 304                                 #endregion
 305
 306                                 this._ストックする();
 307                         }
 308                         finally
 309                         {
 310                                 FDK.Log.EndInfo( $"{FDK.Utilities.現在のメソッド名}" );
 311                         }
 312                 }
 313
 314                 protected override void Onデバイス依存リソースの解放( デバイスリソース dr )
 315                 {
 316                         FDK.Log.BeginInfo( $"{FDK.Utilities.現在のメソッド名}" );
 317
 318                         #region " デコードタスクが起動していたら、終了する。"
 319                         //----------------
 320                         if( null != this._デコードタスク )
 321                         {
 322                                 this._デコードタスクを終了せよ.Set();
 323
 324                                 if( !this._デコードタスク.Wait( 2000 ) )
 325                                         FDK.Log.WARNING( "デコードタスクの終了待ちがタイムアウトしました。" );
 326
 327                                 this._デコードタスク = null;
 328                         }
 329                         //----------------
 330                         #endregion
 331
 332                         FDK.Utilities.解放する( ref this._最後に表示したフレーム );
 333                         FDK.Utilities.解放する( ref this._WicBitmap );
 334                         FDK.Utilities.解放する( ref this._MediaType );
 335                         FDK.Utilities.解放する( ref this._SourceReaderEx );
 336
 337                         this._キューをクリアする();
 338                         this._フレームキュー = null;
 339                         this._デコードタスク用D2DDeviceContext参照 = null;
 340
 341                         FDK.Log.EndInfo( $"{FDK.Utilities.現在のメソッド名}" );
 342                 }
 343
 344                 private int _キューのサイズ = 0;
 345
 346                 private class FrameQueueItem : IDisposable
 347                 {
 348                         public double 表示時刻sec = 0;
 349                         public SharpDX.Direct2D1.Bitmap D2DBitmap = null;
 350
 351                         public void Dispose()
 352                         {
 353                                 FDK.Utilities.解放する( ref this.D2DBitmap );
 354                         }
 355                 }
 356
 357                 private ConcurrentQueue<FrameQueueItem> _フレームキュー = null;
 358
 359                 private FrameQueueItem _最後に表示したフレーム = null;
 360
 361                 private bool _ループ再生する = false;
 362
 363                 private System.Threading.Tasks.Task _デコードタスク = null;
 364
 365                 private System.Threading.AutoResetEvent _デコードタスク起動完了 = null;
 366
 367                 private System.Threading.ManualResetEvent _キューが空いた = null;
 368
 369                 private System.Threading.AutoResetEvent _デコードタスクを終了せよ = null;
 370
 371                 private SharpDX.MediaFoundation.SourceReaderEx _SourceReaderEx = null;
 372
 373                 private SharpDX.MediaFoundation.MediaType _MediaType = null;
 374
 375                 private SharpDX.WIC.Bitmap _WicBitmap = null;    // MediaFoundation は WICBitmap に出力する。
 376
 377                 private SharpDX.Direct2D1.DeviceContext1 _デコードタスク用D2DDeviceContext参照 = null; // D2Dはスレッドセーフであること。
 378
 379                 private void _キューをクリアする()
 380                 {
 381                         while( 0 < this._フレームキュー.Count )
 382                         {
 383                                 var item = (FrameQueueItem) null;
 384                                 if( this._フレームキュー.TryDequeue( out item ) )
 385                                         item.Dispose();
 386                         }
 387
 388                         this._キューが空いた?.Set();
 389                 }
 390
 391                 private void _次のフレームを確認する( out FrameQueueItem フレーム )
 392                 {
 393                         if( ( 0 == this._フレームキュー.Count ) ||
 394                                 ( false == this._フレームキュー.TryPeek( out フレーム ) ) )  // キューから取り出さない
 395                         {
 396                                 フレーム = null;    // キューが空だったか、Peek が一歩遅かった？（ないはずだが
 397                         }
 398                 }
 399
 400                 private void _次のフレームを取り出す( out FrameQueueItem フレーム )
 401                 {
 402                         if( ( 0 == this._フレームキュー.Count ) ||
 403                                 ( false == this._フレームキュー.TryDequeue( out フレーム ) ) )  // キューから取り出す
 404                         {
 405                                 フレーム = null;    // キューが空だったか、Peek が一歩遅かった？（ないはずだが
 406                         }
 407                         else
 408                         {
 409                                 this._キューが空いた.Set();
 410                         }
 411                 }
 412
 413                 private void _D2DBitmapを描画する( デバイスリソース dr, SharpDX.Matrix3x2 変換行列2Dpx, SharpDX.Direct2D1.Bitmap D2DBitmap, float 不透明度 )
 414                 {
 415                         if( null == D2DBitmap )
 416                                 return;
 417
 418                         FDK.Utilities.D2DBatchDraw( dr.D2DContext1, () => {
 419                                 dr.D2DContext1.Transform = 変換行列2Dpx;
 420                                 dr.D2DContext1.PrimitiveBlend = ( this.加算合成 ) ? SharpDX.Direct2D1.PrimitiveBlend.Add : SharpDX.Direct2D1.PrimitiveBlend.SourceOver;
 421                                 dr.D2DContext1.DrawBitmap( D2DBitmap, 不透明度, SharpDX.Direct2D1.InterpolationMode.Linear );
 422                         } );
 423                 }
 424
 425
 426                 // 以下、デコードタスク用。
 427
 428                 private FDK.同期.RWLock<FDK.カウンタ.QPCTimer> _再生タイマ = new 同期.RWLock<カウンタ.QPCTimer>();
 429
 430                 private void _デコードタスクエントリ( object obj再生開始位置sec )
 431                 {
 432                         FDK.Log.Info( "デコードタスクを起動しました。" );
 433
 434                         var 再生開始位置sec = (double) obj再生開始位置sec;
 435
 436                         if( 0.0 < 再生開始位置sec )
 437                         this._再生位置までストリームを進める( 再生開始位置sec );
 438
 439                         const int EVID_キューが空いた = 0;
 440                         const int EVID_デコードタスクを終了せよ = 1;
 441                         var events = new System.Threading.WaitHandle[ 2 ];
 442                         events[ EVID_キューが空いた ] = this._キューが空いた;
 443                         events[ EVID_デコードタスクを終了せよ ] = this._デコードタスクを終了せよ;
 444
 445                         this._デコードタスク起動完了.Set();
 446
 447                         this._再生タイマ.Value.リセットする( FDK.カウンタ.QPCTimer.秒をカウントに変換して返す( 再生開始位置sec ) );
 448
 449                         while( System.Threading.WaitHandle.WaitAny( events ) == EVID_キューが空いた )
 450                         {
 451                                 // キューが空いてるので、サンプルを１つデコードする。
 452                                 if( this._サンプルをひとつデコードしてフレームをキューへ格納する() )
 453                                 {
 454                                         // キューがいっぱいになったら、空くまで待つ。
 455                                         if( _キューのサイズ == this._フレームキュー.Count )
 456                                         {
 457                                                 this._キューが空いた.Reset();   // 次の while で空くのを待つ。
 458                                         }
 459                                 }
 460                                 else
 461                                 {
 462                                         break;  // エラーあるいはストリーム終了 → デコードタスクを終了する。
 463                                 }
 464                         }
 465
 466                         this._デコードタスク = null;
 467
 468                         FDK.Log.Info( "デコードタスクを終了しました。" );
 469                 }
 470
 471                 /// <returns>
 472                 ///             格納できたかスキップした場合は true、エラーあるいはストリーム終了なら false。
 473                 ///     </returns>
 474                 private bool _サンプルをひとつデコードしてフレームをキューへ格納する()
 475                 {
 476                         var sample = (SharpDX.MediaFoundation.Sample) null;
 477                         var bitmap = (SharpDX.Direct2D1.Bitmap) null;
 478
 479                         try
 480                         {
 481                                 long サンプルの表示時刻100ns = 0;
 482
 483                                 #region " ソースリーダーから次のサンプルをひとつデコードする。"
 484                                 //-----------------
 485                                 var ストリームフラグ = SharpDX.MediaFoundation.SourceReaderFlags.None;
 486                                 int 実ストリーム番号 = 0;
 487
 488                                 sample = this._SourceReaderEx.ReadSample(
 489                                         SharpDX.MediaFoundation.SourceReaderIndex.FirstVideoStream,
 490                                         SharpDX.MediaFoundation.SourceReaderControlFlags.None,
 491                                         out 実ストリーム番号,
 492                                         out ストリームフラグ,
 493                                         out サンプルの表示時刻100ns );
 494
 495                                 if( ストリームフラグ.HasFlag( SharpDX.MediaFoundation.SourceReaderFlags.Endofstream ) )  // BOX化コストとか気にしない
 496                                 {
 497                                         #region " ストリーム終了 "
 498                                         //----------------
 499                                         if( this._ループ再生する )
 500                                         {
 501                                                 FDK.Log.Info( "動画をループ再生します。" );
 502                                                 this._SourceReaderEx.SetCurrentPosition( 0 );
 503                                                 return this._サンプルをひとつデコードしてフレームをキューへ格納する();
 504                                         }
 505                                         else
 506                                         {
 507                                                 FDK.Log.Info( "動画の再生を終了します。" );
 508                                                 return false;
 509                                         }
 510                                         //----------------
 511                                         #endregion
 512                                 }
 513                                 else if( ストリームフラグ.HasFlag( SharpDX.MediaFoundation.SourceReaderFlags.Error ) )
 514                                 {
 515                                         #region " エラー。"
 516                                         //----------------
 517                                         throw new SharpDX.SharpDXException( SharpDX.Result.Fail );
 518                                         //----------------
 519                                         #endregion
 520                                 }
 521                                 //else if( ストリームフラグ.HasFlag( SharpDX.MediaFoundation.SourceReaderFlags.Newstream ) )
 522                                 //{
 523                                 //}
 524                                 //else if( ストリームフラグ.HasFlag( SharpDX.MediaFoundation.SourceReaderFlags.Nativemediatypechanged ) )
 525                                 //{
 526                                 //}
 527                                 //else if( ストリームフラグ.HasFlag( SharpDX.MediaFoundation.SourceReaderFlags.Currentmediatypechanged ) )
 528                                 //{
 529                                 //   動画の途中でのサイズ変更には対応しない。
 530                                 //}
 531                                 //else if( ストリームフラグ.HasFlag( SharpDX.MediaFoundation.SourceReaderFlags.StreamTick ) )
 532                                 //{
 533                                 //}
 534                                 //else if( ストリームフラグ.HasFlag( SharpDX.MediaFoundation.SourceReaderFlags.AllEffectsremoved ) )
 535                                 //{
 536                                 //}
 537                                 //---------------------------------------------------
 538                                 #endregion
 539
 540                                 //if( サンプルの表示時刻100ns < this.再生タイマ.Value.現在のリアルタイムカウント100ns単位 )
 541                                 //      return true;    // もう表示時刻は通り過ぎてるのでスキップする。---> この実装だとループのし始めには常に true になってしまうので却下。
 542
 543                                 this._サンプルをビットマップに転送する( sample, out bitmap );
 544
 545                                 this._フレームキュー.Enqueue( new FrameQueueItem()  {
 546                                         D2DBitmap = bitmap,
 547                                         表示時刻sec = サンプルの表示時刻100ns / ( 10.0 * 1000.0 * 1000.0 ),
 548                                 } );
 549
 550                                 bitmap = null;  // キューに格納したので、ここでは Dispose しない。
 551                         }
 552                         catch( Exception e )
 553                         {
 554                                 FDK.Log.Info( $"エラーが発生したので、動画の再生を終了します。[{e.Message}]" );
 555                                 return false;
 556                         }
 557                         finally
 558                         {
 559                                 bitmap?.Dispose();
 560                                 sample?.Dispose();
 561                         }
 562
 563                         return true;
 564                 }
 565
 566                 private void _再生位置までストリームを進める( double 再生位置sec )
 567                 {
 568                         #region " ストリームがシーク不可なら何もしない。"
 569                         //----------------
 570                         var flags = this._SourceReaderEx.GetPresentationAttribute(
 571                                 SharpDX.MediaFoundation.SourceReaderIndex.MediaSource,
 572                                 SharpDX.MediaFoundation.SourceReaderAttributeKeys.MediaSourceCharacteristics );
 573                         if( ( flags & (int) SharpDX.MediaFoundation.MediaSourceCharacteristics.CanSeek ) == 0 )
 574                         {
 575                                 FDK.Log.WARNING( "この動画はシークできないようです。" );
 576                                 return;
 577                         }
 578                         //----------------
 579                         #endregion
 580
 581                         // ストリームの再生位置を移動する。
 582
 583                         this._キューをクリアする();
 584
 585                         long 再生位置100ns = (long) ( 再生位置sec * 1000.0 * 1000.0 * 10.0 );
 586                         this._SourceReaderEx.SetCurrentPosition( 再生位置100ns );
 587
 588                         // キーフレームから再生位置100nsまで ReadSample する。
 589
 590                         var ストリームフラグ = SharpDX.MediaFoundation.SourceReaderFlags.None;
 591                         int 実ストリーム番号 = 0;
 592                         long サンプルの表示時刻100ns = 0;
 593
 594                         while( サンプルの表示時刻100ns < 再生位置100ns )
 595                         {
 596                                 // サンプルを取得。
 597                                 var sample = this._SourceReaderEx.ReadSample(
 598                                         SharpDX.MediaFoundation.SourceReaderIndex.FirstVideoStream,
 599                                         SharpDX.MediaFoundation.SourceReaderControlFlags.None,
 600                                         out 実ストリーム番号,
 601                                         out ストリームフラグ,
 602                                         out サンプルの表示時刻100ns );
 603
 604                                 // 即解放。
 605                                 sample?.Dispose();
 606
 607                                 if( ストリームフラグ.HasFlag( SharpDX.MediaFoundation.SourceReaderFlags.Endofstream ) )
 608                                 {
 609                                         // ストリーム終了。
 610                                         return;
 611                                 }
 612                                 else if( ストリームフラグ.HasFlag( SharpDX.MediaFoundation.SourceReaderFlags.Error ) )
 613                                 {
 614                                         // エラー発生。
 615                                         FDK.Log.ERROR( $"動画の再生位置を移動中に、エラーが発生しました。" );
 616                                         return;
 617                                 }
 618                         }
 619
 620                         this._ストックする();
 621
 622                         FDK.Log.Info( $"動画の再生位置を {再生位置sec}sec へ移動しました。" );
 623                 }
 624
 625                 private void _ストックする()
 626                 {
 627                         for( int i = 0; i < this._キューのサイズ; i++ )
 628                                 this._サンプルをひとつデコードしてフレームをキューへ格納する();
 629
 630                         this._キューが空いた.Reset();    // 埋まった
 631                 }
 632
 633                 private unsafe void _サンプルをビットマップに転送する( SharpDX.MediaFoundation.Sample Sample, out SharpDX.Direct2D1.Bitmap D2DBitmap )
 634                 {
 635                         var buffer = (SharpDX.MediaFoundation.MediaBuffer) null;
 636                         var buffer2d2 = (SharpDX.MediaFoundation.Buffer2D2) null;
 637                         try
 638                         {
 639                                 #region " サンプルからサンプルバッファ (MediaBuffer) を取得する。"
 640                                 //-----------------
 641                                 try
 642                                 {
 643                                         buffer = Sample.ConvertToContiguousBuffer();
 644                                 }
 645                                 catch( Exception e )
 646                                 {
 647                                         Log.ERROR( $"サンプルバッファの取得に失敗しました。(0x{e.HResult:x8})" );
 648                                         throw;
 649                                 }
 650                                 //-----------------
 651                                 #endregion
 652                                 #region " サンプルバッファを Buffer2D2 にキャストする。"
 653                                 //-----------------
 654                                 try
 655                                 {
 656                                         buffer2d2 = buffer.QueryInterface<SharpDX.MediaFoundation.Buffer2D2>();
 657                                 }
 658                                 catch( SharpDX.SharpDXException e )
 659                                 {
 660                                         Log.ERROR( $"サンプルバッファから Buffer2D2 へのキャストに失敗しました。(0x{e.HResult:x8})" );
 661                                         throw;
 662                                 }
 663                                 //-----------------
 664                                 #endregion
 665                                 #region " サンプルバッファをロックする。"
 666                                 //-----------------
 667                                 byte[] scanLine0_bp = new byte[ 8 ];    // 「生ポインタ」が格納される。32bitなら[0～3]、64bitなら[0～7]が有効。（CPUではなく.NETに依存）
 668                                 int pitch = 0;
 669                                 byte[] bufferStart_bp = new byte[ 8 ];  // 「生ポインタ」が格納される。こちらは使わない。
 670                                 int bufferLength;
 671                                 try
 672                                 {
 673                                         buffer2d2.Lock2DSize(
 674                                                 SharpDX.MediaFoundation.Buffer2DLockFlags.Read,
 675                                                 scanLine0_bp,
 676                                                 out pitch,
 677                                                 bufferStart_bp,
 678                                                 out bufferLength );
 679                                 }
 680                                 catch( SharpDX.SharpDXException e )
 681                                 {
 682                                         Log.ERROR( $"サンプルバッファのロックに失敗しました。(0x{e.HResult:x8})" );
 683                                         throw;
 684                                 }
 685                                 //-----------------
 686                                 #endregion
 687                                 try
 688                                 {
 689                                         #region " サンプルバッファのネイティブ先頭アドレスを取得する。"
 690                                         //-----------------
 691                                         byte* scanLine0 = null;
 692                                         try
 693                                         {
 694                                                 scanLine0 = (byte*) this._生ポインタを格納したbyte配列からポインタを取得して返す( scanLine0_bp );
 695                                         }
 696                                         catch( SharpDX.SharpDXException e )
 697                                         {
 698                                                 Log.ERROR( $"サンプルバッファのアドレスの取得に失敗しました。(0x{e.HResult:x8})" );
 699                                                 throw;
 700                                         }
 701                                         //-----------------
 702                                         #endregion
 703                                         #region " サンプルから WicBitmap へ画像をコピーする。"
 704                                         //-----------------
 705                                         try
 706                                         {
 707                                                 // 描画先である WICBitmap をロックする。
 708                                                 using( var bitmapLock = this._WicBitmap.Lock(
 709                                                         new SharpDX.Rectangle( 0, 0, this._WicBitmap.Size.Width, this._WicBitmap.Size.Height ),
 710                                                         SharpDX.WIC.BitmapLockFlags.Write ) )
 711                                                 {
 712                                                         // サンプルバッファからWICビットマップへ、ARGB32 を G8B8R8X8 に変換しながらコピーする。
 713                                                         int bitmapStride = bitmapLock.Stride;
 714                                                         byte* src = scanLine0;
 715                                                         byte* dest = (byte*) bitmapLock.Data.DataPointer.ToPointer();
 716
 717                                                         if( pitch != bitmapStride )
 718                                                         {
 719                                                                 for( int y = 0; y < this.サイズdpx.Height; y++ )
 720                                                                 {
 721                                                                         // ARGB32 to G8B8R8X8 ではデータ変換が不要なので、一行を一気にコピー。
 722                                                                         動画.CopyMemory( dest, src, (int) this.サイズdpx.Width * 4 );   // ARGB=4バイト。
 723                                                                         src += pitch;
 724                                                                         dest += bitmapStride;   // bitmapStride は byte 単位
 725                                                                 }
 726                                                         }
 727                                                         else
 728                                                         {
 729                                                                 // ARGB32 to G8B8R8X8 ではデータ変換が不要、かつ pitch と bitmapStride が等しいので、全行を一括してコピー。
 730                                                                 動画.CopyMemory( dest, src, (int) ( this.サイズdpx.Width * this.サイズdpx.Height * 4 ) );   // ARGB=4バイト。
 731                                                         }
 732                                                 }
 733                                         }
 734                                         catch( SharpDX.SharpDXException e )
 735                                         {
 736                                                 Log.ERROR( $"WicBitmap の Lock に失敗しました。(0x{e.HResult:x8})" );
 737                                                 throw;
 738                                         }
 739                                         catch( Exception e )
 740                                         {
 741                                                 Log.ERROR( $"サンプルバッファから WIC ビットマップへのデータの転送に失敗しました。(0x{e.HResult:x8})" );
 742                                                 throw;
 743                                         }
 744                                         //----------------
 745                                         #endregion
 746                                         #region " WicBitmap から D2DBitmap を生成する。"
 747                                         //----------------
 748                                         try
 749                                         {
 750                                                 D2DBitmap = SharpDX.Direct2D1.Bitmap.FromWicBitmap( this._デコードタスク用D2DDeviceContext参照, this._WicBitmap );
 751                                         }
 752                                         catch( SharpDX.SharpDXException e )
 753                                         {
 754                                                 Log.ERROR( $"D2Dビットマップの作成に失敗しました。(0x{e.HResult:x8})" );
 755                                                 throw;
 756                                         }
 757                                         //----------------
 758                                         #endregion
 759                                 }
 760                                 finally
 761                                 {
 762                                         #region " サンプルバッファのロックを解除する。"
 763                                         //-----------------
 764                                         buffer2d2.Unlock2D();
 765                                         //-----------------
 766                                         #endregion
 767                                 }
 768                         }
 769                         finally
 770                         {
 771                                 FDK.Utilities.解放する( ref buffer2d2 );
 772                                 FDK.Utilities.解放する( ref buffer );
 773                         }
 774                 }
 775
 776                 private unsafe void* _生ポインタを格納したbyte配列からポインタを取得して返す( byte[] 生ポインタ )
 777                 {
 778                         if( ( 4 == IntPtr.Size ) && System.BitConverter.IsLittleEndian )
 779                         {
 780                                 #region " (A) 32bit, リトルエンディアン "
 781                                 //----------------
 782                                 int 生アドレス32bit = 0;
 783
 784                                 for( int i = 0; i < 4; i++ )
 785                                         生アドレス32bit += ( (int) 生ポインタ[ i ] ) << ( i * 8 );
 786
 787                                 return new IntPtr( 生アドレス32bit ).ToPointer();
 788                                 //----------------
 789                                 #endregion
 790                         }
 791                         else if( ( 8 == IntPtr.Size ) && System.BitConverter.IsLittleEndian )
 792                         {
 793                                 #region " (B) 64bit, リトルエンディアン "
 794                                 //----------------
 795                                 long 生アドレス64bit = 0;
 796                                 for( int i = 0; i < 8; i++ )
 797                                         生アドレス64bit += ( (int) 生ポインタ[ i ] ) << ( i * 8 );
 798
 799                                 return new IntPtr( 生アドレス64bit ).ToPointer();
 800                                 //----------------
 801                                 #endregion
 802                         }
 803                         else if( ( 4 == IntPtr.Size ) && ( false == System.BitConverter.IsLittleEndian ) )
 804                         {
 805                                 #region " (C) 32bit, ビッグエンディアン "
 806                                 //----------------
 807                                 int 生アドレス32bit = 0;
 808                                 for( int i = 0; i < 4; i++ )
 809                                         生アドレス32bit += ( (int) 生ポインタ[ 4 - i ] ) << ( i * 8 );
 810
 811                                 return new IntPtr( 生アドレス32bit ).ToPointer();
 812                                 //----------------
 813                                 #endregion
 814                         }
 815                         else if( ( 8 == IntPtr.Size ) && ( false == System.BitConverter.IsLittleEndian ) )
 816                         {
 817                                 #region " (D) 64bit, ビッグエンディアン "
 818                                 //----------------
 819                                 long 生アドレス64bit = 0;
 820                                 for( int i = 0; i < 8; i++ )
 821                                         生アドレス64bit += ( (int) 生ポインタ[ 8 - i ] ) << ( i * 8 );
 822
 823                                 return new IntPtr( 生アドレス64bit ).ToPointer();
 824                                 //----------------
 825                                 #endregion
 826                         }
 827
 828                         throw new SharpDX.SharpDXException( SharpDX.Result.NotImplemented, "この .NET アーキテクチャには対応していません。" );
 829                 }
 830
 831                 #region " Win32 API "
 832                 //-----------------
 833                 [System.Runtime.InteropServices.DllImport( "kernel32.dll", SetLastError = true )]
 834                 private static extern unsafe void CopyMemory( void* dst, void* src, int size );
 835                 //-----------------
 836                 #endregion
 837         }
 838 }