gstreamer/sys/msdk/msdk.c

/* GStreamer Intel MSDK plugin
 * Copyright (c) 2016, Oblong Industries, Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * 3. Neither the name of the copyright holder nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "msdk.h"
#include "gstmsdkvideomemory.h"
#include "gstmsdksystemmemory.h"

GST_DEBUG_CATEGORY_EXTERN (gst_msdkenc_debug);
#define GST_CAT_DEFAULT gst_msdkenc_debug

#define INVALID_INDEX         ((guint) -1)
#define GST_MSDK_ALIGNMENT_PADDING(num) (32 - ((num) & 31))

struct map
{
  GstVideoFormat format;
  mfxU16 mfx_chroma_format;
  mfxU32 mfx_fourcc;
};

#define GST_VIDEO_INFO_TO_MFX_MAP(FORMAT, CHROMA, FOURCC) \
    { GST_VIDEO_FORMAT_##FORMAT, MFX_CHROMAFORMAT_##CHROMA, MFX_FOURCC_##FOURCC }

static const struct map gst_msdk_video_format_to_mfx_map[] = {
  GST_VIDEO_INFO_TO_MFX_MAP (NV12, YUV420, NV12),
  GST_VIDEO_INFO_TO_MFX_MAP (YV12, YUV420, YV12),
  GST_VIDEO_INFO_TO_MFX_MAP (I420, YUV420, YV12),
  GST_VIDEO_INFO_TO_MFX_MAP (YUY2, YUV422, YUY2),
  GST_VIDEO_INFO_TO_MFX_MAP (UYVY, YUV422, UYVY),
  GST_VIDEO_INFO_TO_MFX_MAP (BGRA, YUV444, RGB4),
  {0, 0, 0}
};

static inline guint
msdk_get_free_surface_index (mfxFrameSurface1 * surfaces, guint size)
{
  if (surfaces) {
    guint i;

    for (i = 0; i < size; i++) {
      if (!surfaces[i].Data.Locked)
        return i;
    }
  }

  return INVALID_INDEX;
}

mfxFrameSurface1 *
msdk_get_free_surface (mfxFrameSurface1 * surfaces, guint size)
{
  guint idx = INVALID_INDEX;
  guint i;

  /* Poll the pool for a maximum of 20 milisecnds */
  for (i = 0; i < 2000; i++) {
    idx = msdk_get_free_surface_index (surfaces, size);

    if (idx != INVALID_INDEX)
      break;

    g_usleep (10);
  }

  return (idx == INVALID_INDEX ? NULL : &surfaces[idx]);
}

/* FIXME: Only NV12 is supported by now, add other YUV formats */
void
msdk_frame_to_surface (GstVideoFrame * frame, mfxFrameSurface1 * surface)
{
  guint8 *src, *dst;
  guint sstride, dstride;
  guint width, height;
  guint i, p;

  if (!surface->Data.MemId) {
    switch (frame->info.finfo->format) {
      case GST_VIDEO_FORMAT_NV12:
        surface->Data.Y = GST_VIDEO_FRAME_COMP_DATA (frame, 0);
        surface->Data.UV = GST_VIDEO_FRAME_COMP_DATA (frame, 1);
        surface->Data.Pitch = GST_VIDEO_FRAME_COMP_STRIDE (frame, 0);
        break;

      case GST_VIDEO_FORMAT_YV12:
      case GST_VIDEO_FORMAT_I420:
        surface->Data.Y = GST_VIDEO_FRAME_COMP_DATA (frame, 0);
        surface->Data.U = GST_VIDEO_FRAME_COMP_DATA (frame, 1);
        surface->Data.V = GST_VIDEO_FRAME_COMP_DATA (frame, 2);
        surface->Data.Pitch = GST_VIDEO_FRAME_COMP_STRIDE (frame, 0);
        break;

      case GST_VIDEO_FORMAT_YUY2:
        surface->Data.Y = GST_VIDEO_FRAME_PLANE_DATA (frame, 0);
        surface->Data.Pitch = GST_VIDEO_FRAME_COMP_STRIDE (frame, 0);
        surface->Data.U = surface->Data.Y + 1;
        surface->Data.V = surface->Data.Y + 3;
        break;
      case GST_VIDEO_FORMAT_UYVY:
        surface->Data.Y = GST_VIDEO_FRAME_PLANE_DATA (frame, 0);
        surface->Data.Pitch = GST_VIDEO_FRAME_COMP_STRIDE (frame, 0);
        surface->Data.U = surface->Data.Y;
        surface->Data.Y = surface->Data.U + 1;
        surface->Data.V = surface->Data.U + 2;
        break;

      case GST_VIDEO_FORMAT_BGRA:
        surface->Data.R = GST_VIDEO_FRAME_COMP_DATA (frame, 0);
        surface->Data.G = surface->Data.R - 1;
        surface->Data.B = surface->Data.R - 2;
        surface->Data.Pitch = GST_VIDEO_FRAME_COMP_STRIDE (frame, 0);
        break;

      default:
        g_assert_not_reached ();
        break;
    }

    return;
  }


  switch (frame->info.finfo->format) {
    case GST_VIDEO_FORMAT_NV12:
      width = GST_VIDEO_FRAME_COMP_WIDTH (frame, 0);
      for (p = 0; p < 2; p++) {
        height = GST_VIDEO_FRAME_COMP_HEIGHT (frame, p);
        src = GST_VIDEO_FRAME_COMP_DATA (frame, p);
        sstride = GST_VIDEO_FRAME_COMP_STRIDE (frame, p);
        dst = p == 0 ? surface->Data.Y : surface->Data.UV;
        dstride = surface->Data.Pitch;

        for (i = 0; i < height; i++) {
          memcpy (dst, src, width);
          src += sstride;
          dst += dstride;
        }
      }
      break;

    case GST_VIDEO_FORMAT_YV12:
    case GST_VIDEO_FORMAT_I420:
      for (p = 0; p < 3; p++) {
        width = GST_VIDEO_FRAME_COMP_WIDTH (frame, p);
        height = GST_VIDEO_FRAME_COMP_HEIGHT (frame, p);
        src = GST_VIDEO_FRAME_COMP_DATA (frame, p);
        sstride = GST_VIDEO_FRAME_COMP_STRIDE (frame, p);
        switch (p) {
          case 0:
            dst = surface->Data.Y;
            break;
          case 1:
            dst = surface->Data.U;
            break;
          case 2:
            dst = surface->Data.V;
            break;
          default:
            g_assert_not_reached ();
            break;
        }
        dstride = surface->Data.Pitch;
        if (p > 0)
          dstride = dstride / 2;

        for (i = 0; i < height; i++) {
          memcpy (dst, src, width);
          src += sstride;
          dst += dstride;
        }
      }
      break;

    case GST_VIDEO_FORMAT_YUY2:
    case GST_VIDEO_FORMAT_UYVY:
      width = GST_VIDEO_FRAME_COMP_WIDTH (frame, 0);
      height = GST_VIDEO_FRAME_COMP_HEIGHT (frame, 0);
      src = GST_VIDEO_FRAME_COMP_DATA (frame, 0);
      sstride = GST_VIDEO_FRAME_COMP_STRIDE (frame, 0);
      dst = surface->Data.Y;
      dstride = surface->Data.Pitch;

      width *= 2;
      width = MIN (sstride, width);

      for (i = 0; i < height; i++) {
        memcpy (dst, src, width);
        src += sstride;
        dst += dstride;
      }
      break;

    case GST_VIDEO_FORMAT_BGRA:
      width = GST_VIDEO_FRAME_COMP_WIDTH (frame, 0);
      height = GST_VIDEO_FRAME_COMP_HEIGHT (frame, 0);
      src = GST_VIDEO_FRAME_COMP_DATA (frame, 0);
      sstride = GST_VIDEO_FRAME_COMP_STRIDE (frame, 0);
      dst = surface->Data.B;
      dstride = surface->Data.Pitch;

      width *= 4;

      for (i = 0; i < height; i++) {
        memcpy (dst, src, width);
        src += sstride;
        dst += dstride;
      }
      break;

    default:
      g_assert_not_reached ();
      break;
  }
}

const gchar *
msdk_status_to_string (mfxStatus status)
{
  switch (status) {
      /* no error */
    case MFX_ERR_NONE:
      return "no error";
      /* reserved for unexpected errors */
    case MFX_ERR_UNKNOWN:
      return "unknown error";
      /* error codes <0 */
    case MFX_ERR_NULL_PTR:
      return "null pointer";
    case MFX_ERR_UNSUPPORTED:
      return "undeveloped feature";
    case MFX_ERR_MEMORY_ALLOC:
      return "failed to allocate memory";
    case MFX_ERR_NOT_ENOUGH_BUFFER:
      return "insufficient buffer at input/output";
    case MFX_ERR_INVALID_HANDLE:
      return "invalid handle";
    case MFX_ERR_LOCK_MEMORY:
      return "failed to lock the memory block";
    case MFX_ERR_NOT_INITIALIZED:
      return "member function called before initialization";
    case MFX_ERR_NOT_FOUND:
      return "the specified object is not found";
    case MFX_ERR_MORE_DATA:
      return "expect more data at input";
    case MFX_ERR_MORE_SURFACE:
      return "expect more surface at output";
    case MFX_ERR_ABORTED:
      return "operation aborted";
    case MFX_ERR_DEVICE_LOST:
      return "lose the HW acceleration device";
    case MFX_ERR_INCOMPATIBLE_VIDEO_PARAM:
      return "incompatible video parameters";
    case MFX_ERR_INVALID_VIDEO_PARAM:
      return "invalid video parameters";
    case MFX_ERR_UNDEFINED_BEHAVIOR:
      return "undefined behavior";
    case MFX_ERR_DEVICE_FAILED:
      return "device operation failure";
    case MFX_ERR_MORE_BITSTREAM:
      return "expect more bitstream buffers at output";
    case MFX_ERR_INCOMPATIBLE_AUDIO_PARAM:
      return "incompatible audio parameters";
    case MFX_ERR_INVALID_AUDIO_PARAM:
      return "invalid audio parameters";
      /* warnings >0 */
    case MFX_WRN_IN_EXECUTION:
      return "the previous asynchronous operation is in execution";
    case MFX_WRN_DEVICE_BUSY:
      return "the HW acceleration device is busy";
    case MFX_WRN_VIDEO_PARAM_CHANGED:
      return "the video parameters are changed during decoding";
    case MFX_WRN_PARTIAL_ACCELERATION:
      return "SW is used";
    case MFX_WRN_INCOMPATIBLE_VIDEO_PARAM:
      return "incompatible video parameters";
    case MFX_WRN_VALUE_NOT_CHANGED:
      return "the value is saturated based on its valid range";
    case MFX_WRN_OUT_OF_RANGE:
      return "the value is out of valid range";
    case MFX_WRN_FILTER_SKIPPED:
      return "one of requested filters has been skipped";
    case MFX_WRN_INCOMPATIBLE_AUDIO_PARAM:
      return "incompatible audio parameters";
    default:
      break;
  }
  return "undefiend error";
}

void
msdk_close_session (mfxSession session)
{
  mfxStatus status;

  if (!session)
    return;

  status = MFXClose (session);
  if (status != MFX_ERR_NONE)
    GST_ERROR ("Close failed (%s)", msdk_status_to_string (status));
}

mfxSession
msdk_open_session (gboolean hardware)
{
  mfxSession session = NULL;
  mfxVersion version = { {1, 1}
  };
  mfxIMPL implementation;
  mfxStatus status;

  static const gchar *implementation_names[] = {
    "AUTO", "SOFTWARE", "HARDWARE", "AUTO_ANY", "HARDWARE_ANY", "HARDWARE2",
    "HARDWARE3", "HARDWARE4", "RUNTIME"
  };

  status = MFXInit (hardware ? MFX_IMPL_HARDWARE_ANY : MFX_IMPL_SOFTWARE,
      &version, &session);
  if (status != MFX_ERR_NONE) {
    GST_ERROR ("Intel Media SDK not available (%s)",
        msdk_status_to_string (status));
    goto failed;
  }

  MFXQueryIMPL (session, &implementation);
  if (status != MFX_ERR_NONE) {
    GST_ERROR ("Query implementation failed (%s)",
        msdk_status_to_string (status));
    goto failed;
  }

  MFXQueryVersion (session, &version);
  if (status != MFX_ERR_NONE) {
    GST_ERROR ("Query version failed (%s)", msdk_status_to_string (status));
    goto failed;
  }

  GST_INFO ("MSDK implementation: 0x%04x (%s)", implementation,
      implementation_names[MFX_IMPL_BASETYPE (implementation)]);
  GST_INFO ("MSDK version: %d.%d", version.Major, version.Minor);

  return session;

failed:
  msdk_close_session (session);
  return NULL;
}

gboolean
msdk_is_available (void)
{
  mfxSession session = msdk_open_session (FALSE);
  if (!session) {
    return FALSE;
  }

  msdk_close_session (session);
  return TRUE;
}

void
gst_msdk_set_video_alignment (GstVideoInfo * info,
    GstVideoAlignment * alignment)
{
  guint i, width, height;

  width = GST_VIDEO_INFO_WIDTH (info);
  height = GST_VIDEO_INFO_HEIGHT (info);

  gst_video_alignment_reset (alignment);
  for (i = 0; i < GST_VIDEO_INFO_N_PLANES (info); i++)
    alignment->stride_align[i] = 31;    /* 32-byte alignment */

  if (width & 31)
    alignment->padding_right = GST_MSDK_ALIGNMENT_PADDING (width);
  if (height & 31)
    alignment->padding_bottom = GST_MSDK_ALIGNMENT_PADDING (height);
}

static const struct map *
_map_lookup_format (GstVideoFormat format)
{
  const struct map *m = gst_msdk_video_format_to_mfx_map;

  for (; m->format != 0; m++) {
    if (m->format == format)
      return m;
  }
  return NULL;
}

gint
gst_msdk_get_mfx_chroma_from_format (GstVideoFormat format)
{
  const struct map *const m = _map_lookup_format (format);

  return m ? m->mfx_chroma_format : -1;
}

gint
gst_msdk_get_mfx_fourcc_from_format (GstVideoFormat format)
{
  const struct map *const m = _map_lookup_format (format);

  return m ? m->mfx_fourcc : -1;
}

void
gst_msdk_set_mfx_frame_info_from_video_info (mfxFrameInfo * mfx_info,
    GstVideoInfo * info)
{
  g_return_if_fail (info && mfx_info);

  mfx_info->Width = GST_ROUND_UP_32 (GST_VIDEO_INFO_WIDTH (info));
  mfx_info->Height = GST_ROUND_UP_32 (GST_VIDEO_INFO_HEIGHT (info));
  mfx_info->CropW = GST_VIDEO_INFO_WIDTH (info);
  mfx_info->CropH = GST_VIDEO_INFO_HEIGHT (info);
  mfx_info->FrameRateExtN = GST_VIDEO_INFO_FPS_N (info);
  mfx_info->FrameRateExtD = GST_VIDEO_INFO_FPS_D (info);
  mfx_info->AspectRatioW = GST_VIDEO_INFO_PAR_N (info);
  mfx_info->AspectRatioH = GST_VIDEO_INFO_PAR_D (info);
  mfx_info->PicStruct = MFX_PICSTRUCT_PROGRESSIVE;      /* this is by default */
  mfx_info->FourCC =
      gst_msdk_get_mfx_fourcc_from_format (GST_VIDEO_INFO_FORMAT (info));
  mfx_info->ChromaFormat =
      gst_msdk_get_mfx_chroma_from_format (GST_VIDEO_INFO_FORMAT (info));

  return;
}

gboolean
gst_msdk_is_msdk_buffer (GstBuffer * buf)
{
  GstAllocator *allocator;
  GstMemory *mem = gst_buffer_peek_memory (buf, 0);

  allocator = GST_MEMORY_CAST (mem)->allocator;

  if (allocator && (GST_IS_MSDK_VIDEO_ALLOCATOR (allocator) ||
          GST_IS_MSDK_SYSTEM_ALLOCATOR (allocator)))
    return TRUE;
  else
    return FALSE;
}

mfxFrameSurface1 *
gst_msdk_get_surface_from_buffer (GstBuffer * buf)
{
  GstAllocator *allocator;
  GstMemory *mem = gst_buffer_peek_memory (buf, 0);

  allocator = GST_MEMORY_CAST (mem)->allocator;

  if (GST_IS_MSDK_VIDEO_ALLOCATOR (allocator))
    return GST_MSDK_VIDEO_MEMORY_CAST (mem)->surface;
  else
    return GST_MSDK_SYSTEM_MEMORY_CAST (mem)->surface;
}