media/gmp-clearkey/0.1/WMFH264Decoder.cpp

   1 /*
   2  * Copyright 2013, Mozilla Foundation and contributors
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "WMFH264Decoder.h"
  18 #include <algorithm>
  19
  20 namespace wmf {
  21
  22 WMFH264Decoder::WMFH264Decoder()
  23   : mDecoder(nullptr)
  24 {
  25   memset(&mInputStreamInfo, 0, sizeof(MFT_INPUT_STREAM_INFO));
  26   memset(&mOutputStreamInfo, 0, sizeof(MFT_OUTPUT_STREAM_INFO));
  27 }
  28
  29 WMFH264Decoder::~WMFH264Decoder()
  30 {
  31 }
  32
  33 HRESULT
  34 WMFH264Decoder::Init()
  35 {
  36   HRESULT hr;
  37
  38   hr = CreateMFT(__uuidof(CMSH264DecoderMFT),
  39                  "msmpeg2vdec.dll",
  40                  mDecoder);
  41   ENSURE(SUCCEEDED(hr), hr);
  42
  43   hr = SetDecoderInputType();
  44   ENSURE(SUCCEEDED(hr), hr);
  45
  46   hr = SetDecoderOutputType();
  47   ENSURE(SUCCEEDED(hr), hr);
  48
  49   hr = SendMFTMessage(MFT_MESSAGE_NOTIFY_BEGIN_STREAMING, 0);
  50   ENSURE(SUCCEEDED(hr), hr);
  51
  52   hr = SendMFTMessage(MFT_MESSAGE_NOTIFY_START_OF_STREAM, 0);
  53   ENSURE(SUCCEEDED(hr), hr);
  54
  55   hr = mDecoder->GetInputStreamInfo(0, &mInputStreamInfo);
  56   ENSURE(SUCCEEDED(hr), hr);
  57
  58   hr = mDecoder->GetOutputStreamInfo(0, &mOutputStreamInfo);
  59   ENSURE(SUCCEEDED(hr), hr);
  60
  61   return S_OK;
  62 }
  63
  64 HRESULT
  65 WMFH264Decoder::ConfigureVideoFrameGeometry(IMFMediaType* aMediaType)
  66 {
  67   ENSURE(aMediaType != nullptr, E_POINTER);
  68   HRESULT hr;
  69
  70   IntRect pictureRegion;
  71   hr = wmf::GetPictureRegion(aMediaType, pictureRegion);
  72   ENSURE(SUCCEEDED(hr), hr);
  73
  74   UINT32 width = 0, height = 0;
  75   hr = MFGetAttributeSize(aMediaType, MF_MT_FRAME_SIZE, &width, &height);
  76   ENSURE(SUCCEEDED(hr), hr);
  77
  78   // Success! Save state.
  79   GetDefaultStride(aMediaType, (UINT32*)&mStride);
  80   mVideoWidth = width;
  81   mVideoHeight = height;
  82   mPictureRegion = pictureRegion;
  83
  84   LOG("WMFH264Decoder frame geometry frame=(%u,%u) stride=%u picture=(%d, %d, %d, %d)\n",
  85       width, height,
  86       mStride,
  87       mPictureRegion.x, mPictureRegion.y, mPictureRegion.width, mPictureRegion.height);
  88
  89   return S_OK;
  90 }
  91
  92 int32_t
  93 WMFH264Decoder::GetFrameWidth() const
  94 {
  95   return mVideoWidth;
  96 }
  97
  98 int32_t
  99 WMFH264Decoder::GetFrameHeight() const
 100 {
 101   return mVideoHeight;
 102 }
 103
 104 const IntRect&
 105 WMFH264Decoder::GetPictureRegion() const
 106 {
 107   return mPictureRegion;
 108 }
 109
 110 int32_t
 111 WMFH264Decoder::GetStride() const
 112 {
 113   return mStride;
 114 }
 115
 116 HRESULT
 117 WMFH264Decoder::SetDecoderInputType()
 118 {
 119   HRESULT hr;
 120
 121   CComPtr<IMFMediaType> type;
 122   hr = MFCreateMediaType(&type);
 123   ENSURE(SUCCEEDED(hr), hr);
 124
 125   hr = type->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video);
 126   ENSURE(SUCCEEDED(hr), hr);
 127
 128   hr = type->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_H264);
 129   ENSURE(SUCCEEDED(hr), hr);
 130
 131   hr = type->SetUINT32(MF_MT_INTERLACE_MODE, MFVideoInterlace_MixedInterlaceOrProgressive);
 132   ENSURE(SUCCEEDED(hr), hr);
 133
 134   hr = mDecoder->SetInputType(0, type, 0);
 135   ENSURE(SUCCEEDED(hr), hr);
 136
 137   return S_OK;
 138 }
 139
 140 HRESULT
 141 WMFH264Decoder::SetDecoderOutputType()
 142 {
 143   HRESULT hr;
 144
 145   CComPtr<IMFMediaType> type;
 146
 147   UINT32 typeIndex = 0;
 148   while (type = nullptr, SUCCEEDED(mDecoder->GetOutputAvailableType(0, typeIndex++, &type))) {
 149     GUID subtype;
 150     hr = type->GetGUID(MF_MT_SUBTYPE, &subtype);
 151     if (FAILED(hr)) {
 152       continue;
 153     }
 154     if (subtype == MFVideoFormat_I420) {
 155       hr = mDecoder->SetOutputType(0, type, 0);
 156       ENSURE(SUCCEEDED(hr), hr);
 157
 158       hr = ConfigureVideoFrameGeometry(type);
 159       ENSURE(SUCCEEDED(hr), hr);
 160
 161       return S_OK;
 162     }
 163   }
 164
 165   return E_FAIL;
 166 }
 167
 168 HRESULT
 169 WMFH264Decoder::SendMFTMessage(MFT_MESSAGE_TYPE aMsg, UINT32 aData)
 170 {
 171   ENSURE(mDecoder != nullptr, E_POINTER);
 172   HRESULT hr = mDecoder->ProcessMessage(aMsg, aData);
 173   ENSURE(SUCCEEDED(hr), hr);
 174   return S_OK;
 175 }
 176
 177 HRESULT
 178 WMFH264Decoder::CreateInputSample(const uint8_t* aData,
 179                                   uint32_t aDataSize,
 180                                   Microseconds aTimestamp,
 181                                   Microseconds aDuration,
 182                                   IMFSample** aOutSample)
 183 {
 184   HRESULT hr;
 185   CComPtr<IMFSample> sample;
 186   hr = MFCreateSample(&sample);
 187   ENSURE(SUCCEEDED(hr), hr);
 188
 189   CComPtr<IMFMediaBuffer> buffer;
 190   int32_t bufferSize = std::max<uint32_t>(uint32_t(mInputStreamInfo.cbSize), aDataSize);
 191   UINT32 alignment = (mInputStreamInfo.cbAlignment > 1) ? mInputStreamInfo.cbAlignment - 1 : 0;
 192   hr = MFCreateAlignedMemoryBuffer(bufferSize, alignment, &buffer);
 193   ENSURE(SUCCEEDED(hr), hr);
 194
 195   DWORD maxLength = 0;
 196   DWORD currentLength = 0;
 197   BYTE* dst = nullptr;
 198   hr = buffer->Lock(&dst, &maxLength, &currentLength);
 199   ENSURE(SUCCEEDED(hr), hr);
 200
 201   // Copy data into sample's buffer.
 202   memcpy(dst, aData, aDataSize);
 203
 204   hr = buffer->Unlock();
 205   ENSURE(SUCCEEDED(hr), hr);
 206
 207   hr = buffer->SetCurrentLength(aDataSize);
 208   ENSURE(SUCCEEDED(hr), hr);
 209
 210   hr = sample->AddBuffer(buffer);
 211   ENSURE(SUCCEEDED(hr), hr);
 212
 213   hr = sample->SetSampleTime(UsecsToHNs(aTimestamp));
 214   ENSURE(SUCCEEDED(hr), hr);
 215
 216   sample->SetSampleDuration(UsecsToHNs(aDuration));
 217
 218   *aOutSample = sample.Detach();
 219
 220   return S_OK;
 221 }
 222
 223 HRESULT
 224 WMFH264Decoder::CreateOutputSample(IMFSample** aOutSample)
 225 {
 226   HRESULT hr;
 227   CComPtr<IMFSample> sample;
 228   hr = MFCreateSample(&sample);
 229   ENSURE(SUCCEEDED(hr), hr);
 230
 231   CComPtr<IMFMediaBuffer> buffer;
 232   int32_t bufferSize = mOutputStreamInfo.cbSize;
 233   UINT32 alignment = (mOutputStreamInfo.cbAlignment > 1) ? mOutputStreamInfo.cbAlignment - 1 : 0;
 234   hr = MFCreateAlignedMemoryBuffer(bufferSize, alignment, &buffer);
 235   ENSURE(SUCCEEDED(hr), hr);
 236
 237   hr = sample->AddBuffer(buffer);
 238   ENSURE(SUCCEEDED(hr), hr);
 239
 240   *aOutSample = sample.Detach();
 241
 242   return S_OK;
 243 }
 244
 245
 246 HRESULT
 247 WMFH264Decoder::GetOutputSample(IMFSample** aOutSample)
 248 {
 249   HRESULT hr;
 250   // We allocate samples for MFT output.
 251   MFT_OUTPUT_DATA_BUFFER output = {0};
 252
 253   CComPtr<IMFSample> sample;
 254   hr = CreateOutputSample(&sample);
 255   ENSURE(SUCCEEDED(hr), hr);
 256
 257   output.pSample = sample;
 258
 259   DWORD status = 0;
 260   hr = mDecoder->ProcessOutput(0, 1, &output, &status);
 261   //LOG(L"WMFH264Decoder::GetOutputSample() ProcessOutput returned 0x%x\n", hr);
 262   CComPtr<IMFCollection> events = output.pEvents; // Ensure this is released.
 263
 264   if (hr == MF_E_TRANSFORM_STREAM_CHANGE) {
 265     // Type change. Probably geometric apperature change.
 266     hr = SetDecoderOutputType();
 267     ENSURE(SUCCEEDED(hr), hr);
 268
 269     return GetOutputSample(aOutSample);
 270   } else if (hr == MF_E_TRANSFORM_NEED_MORE_INPUT) {
 271     return MF_E_TRANSFORM_NEED_MORE_INPUT;
 272   }
 273   // Treat other errors as fatal.
 274   ENSURE(SUCCEEDED(hr), hr);
 275
 276   assert(sample);
 277
 278   // output.pSample
 279   *aOutSample = sample.Detach(); // AddRefs
 280   return S_OK;
 281 }
 282
 283 HRESULT
 284 WMFH264Decoder::Input(const uint8_t* aData,
 285                       uint32_t aDataSize,
 286                       Microseconds aTimestamp,
 287                       Microseconds aDuration)
 288 {
 289   HRESULT hr;
 290   CComPtr<IMFSample> input = nullptr;
 291   hr = CreateInputSample(aData, aDataSize, aTimestamp, aDuration, &input);
 292   ENSURE(SUCCEEDED(hr) && input!=nullptr, hr);
 293
 294   hr = mDecoder->ProcessInput(0, input, 0);
 295   if (hr == MF_E_NOTACCEPTING) {
 296     // MFT *already* has enough data to produce a sample. Retrieve it.
 297     LOG("ProcessInput returned MF_E_NOTACCEPTING\n");
 298     return MF_E_NOTACCEPTING;
 299   }
 300   ENSURE(SUCCEEDED(hr), hr);
 301
 302   return S_OK;
 303 }
 304
 305 HRESULT
 306 WMFH264Decoder::Output(IMFSample** aOutput)
 307 {
 308   HRESULT hr;
 309   CComPtr<IMFSample> outputSample;
 310   hr = GetOutputSample(&outputSample);
 311   if (hr == MF_E_TRANSFORM_NEED_MORE_INPUT) {
 312     return MF_E_TRANSFORM_NEED_MORE_INPUT;
 313   }
 314   // Treat other errors as fatal.
 315   ENSURE(SUCCEEDED(hr) && outputSample, hr);
 316
 317   *aOutput = outputSample.Detach();
 318
 319   return S_OK;
 320 }
 321
 322 HRESULT
 323 WMFH264Decoder::Reset()
 324 {
 325   HRESULT hr = SendMFTMessage(MFT_MESSAGE_COMMAND_FLUSH, 0);
 326   ENSURE(SUCCEEDED(hr), hr);
 327
 328   return S_OK;
 329 }
 330
 331 HRESULT
 332 WMFH264Decoder::Drain()
 333 {
 334   HRESULT hr = SendMFTMessage(MFT_MESSAGE_COMMAND_DRAIN, 0);
 335   ENSURE(SUCCEEDED(hr), hr);
 336
 337   return S_OK;
 338 }
 339
 340 } // namespace wmf