private void ConfigureVideo(VideoMediaFormat format, bool encoder,
MediaCodecTypes supportType)
{
int codecType = (int)format.MimeType & CodecTypeMask;
if (!Enum.IsDefined(typeof(SupportedCodecType), codecType))
{
throw new NotSupportedException("The format is not supported." +
$"mime type : { Enum.GetName(typeof(MediaFormatVideoMimeType), format.MimeType) }");
}
DoConfigure(codecType, encoder, supportType);
if (encoder)
{
int ret = Interop.MediaCodec.SetVideoEncoderInfo(_handle, format.Size.Width,
format.Size.Height, format.FrameRate, format.BitRate / 1000);
MultimediaDebug.AssertNoError(ret);
}
else
{
int ret = Interop.MediaCodec.SetVideoDecoderInfo(_handle, format.Size.Width, format.Size.Height);
MultimediaDebug.AssertNoError(ret);
}
}
private void RegisterOutputAvailableCallback()
{
_outputBufferAvailableCb = (packetHandle, _) =>
{
if (_outputAvailable == null)
{
Interop.MediaPacket.Destroy(packetHandle);
return;
}
OutputAvailableEventArgs args = null;
try
{
args = new OutputAvailableEventArgs(packetHandle);
}
catch (Exception e)
{
Interop.MediaPacket.Destroy(packetHandle);
MultimediaLog.Error(typeof(MediaCodec).FullName, "Failed to raise OutputAvailable event", e);
}
if (args != null)
{
_outputAvailable?.Invoke(this, args);
}
};
int ret = Interop.MediaCodec.SetOutputBufferAvailableCb(_handle, _outputBufferAvailableCb);
MultimediaDebug.AssertNoError(ret);
}
private void ConfigureAudio(AudioMediaFormat format, bool encoder,
MediaCodecTypes supportType)
{
int codecType = (int)format.MimeType & CodecTypeMask;
if (!Enum.IsDefined(typeof(SupportedCodecType), codecType))
{
throw new NotSupportedException("The format is not supported " +
$"mime type : { Enum.GetName(typeof(MediaFormatAudioMimeType), format.MimeType) }");
}
DoConfigure(codecType, encoder, supportType);
if (encoder)
{
int ret = Interop.MediaCodec.SetAudioEncoderInfo(_handle, format.SampleRate,
format.Channel, format.Bit, format.BitRate);
MultimediaDebug.AssertNoError(ret);
}
else
{
int ret = Interop.MediaCodec.SetAudioDecoderInfo(_handle, format.SampleRate,
format.Channel, format.Bit);
MultimediaDebug.AssertNoError(ret);
}
}
private static void LoadSupportedCodec()
{
var videoCodecList = new List <MediaFormatVideoMimeType>();
var audioCodecList = new List <MediaFormatAudioMimeType>();
Interop.MediaCodec.SupportedCodecCallback cb = (codecType, _) =>
{
if ((codecType & CodecKindMask) == CodecKindVideo)
{
MediaFormatVideoMimeType mimeType = 0;
if (TryGetMimeTypeFromCodecType(codecType, ref mimeType))
{
videoCodecList.Add(mimeType);
}
}
else
{
MediaFormatAudioMimeType mimeType = 0;
if (TryGetMimeTypeFromCodecType(codecType, ref mimeType))
{
audioCodecList.Add(mimeType);
}
}
return(true);
};
int ret = Interop.MediaCodec.ForeachSupportedCodec(cb, IntPtr.Zero);
MultimediaDebug.AssertNoError(ret);
_supportedVideoCodecs = videoCodecList.AsReadOnly();
_supportedAudioCodecs = audioCodecList.AsReadOnly();
}
private void RegisterEosReached()
{
_eosCb = _ => EosReached?.Invoke(this, EventArgs.Empty);
int ret = Interop.MediaCodec.SetEosCb(_handle, _eosCb);
MultimediaDebug.AssertNoError(ret);
}
/// <summary>
/// Flushes both input and output buffers.
/// </summary>
/// <since_tizen> 3 </since_tizen>
public void FlushBuffers()
{
ValidateNotDisposed();
int ret = Interop.MediaCodec.FlushBuffers(_handle);
MultimediaDebug.AssertNoError(ret);
}
/// <summary>
/// Unprepares the MediaCodec.
/// </summary>
/// <since_tizen> 3 </since_tizen>
public void Unprepare()
{
ValidateNotDisposed();
int ret = Interop.MediaCodec.Unprepare(_handle);
MultimediaDebug.AssertNoError(ret);
}
private MediaCodecTypes GetCodecType(int mimeType, bool isEncoder)
{
int codecType = mimeType & CodecTypeMask;
int value = 0;
int ret = Interop.MediaCodec.GetSupportedType(_handle, codecType, isEncoder, out value);
MultimediaDebug.AssertNoError(ret);
return((MediaCodecTypes)value);
}
private void RegisterErrorOccurred()
{
_errorCb = (errorCode, _) =>
{
MediaCodecError error = (Enum.IsDefined(typeof(MediaCodecError), errorCode)) ?
(MediaCodecError)errorCode : MediaCodecError.InternalError;
ErrorOccurred?.Invoke(this, new MediaCodecErrorOccurredEventArgs(error));
};
int ret = Interop.MediaCodec.SetErrorCb(_handle, _errorCb);
MultimediaDebug.AssertNoError(ret);
}
/// <summary>
/// Initializes a new instance of the MediaCodec class.
/// </summary>
/// <since_tizen> 3 </since_tizen>
public MediaCodec()
{
int ret = Interop.MediaCodec.Create(out _handle);
if (ret == (int)MediaCodecErrorCode.InvalidOperation)
{
throw new InvalidOperationException("Not able to initialize a new media codec.");
}
MultimediaDebug.AssertNoError(ret);
RegisterInputProcessed();
RegisterErrorOccurred();
}
private void RegisterBufferStatusChanged()
{
_bufferStatusCb = (statusCode, _) =>
{
Debug.Assert(Enum.IsDefined(typeof(MediaCodecStatus), statusCode),
$"{ statusCode } is not defined in MediaCodecStatus!");
BufferStatusChanged?.Invoke(this,
new BufferStatusChangedEventArgs((MediaCodecStatus)statusCode));
};
int ret = Interop.MediaCodec.SetBufferStatusCb(_handle, _bufferStatusCb);
MultimediaDebug.AssertNoError(ret);
}
private void DoConfigure(int codecType, bool encoder, MediaCodecTypes supportType)
{
Debug.Assert(Enum.IsDefined(typeof(SupportedCodecType), codecType));
int flags = (int)(encoder ? MediaCodecCodingType.Encoder : MediaCodecCodingType.Decoder);
flags |= (int)supportType;
int ret = Interop.MediaCodec.Configure(_handle, codecType, flags);
if (ret == (int)MediaCodecErrorCode.NotSupportedOnDevice)
{
throw new NotSupportedException("The format is not supported.");
}
MultimediaDebug.AssertNoError(ret);
}
/// <summary>
/// Prepares the MediaCodec for encoding or decoding.
/// </summary>
/// <exception cref="InvalidOperationException">
/// The codec is not configured yet.<br/>
/// -or-<br/>
/// Internal error.
/// </exception>
/// <since_tizen> 3 </since_tizen>
public void Prepare()
{
ValidateNotDisposed();
int ret = Interop.MediaCodec.Prepare(_handle);
if (ret == (int)MediaCodecErrorCode.NotInitialized)
{
throw new InvalidOperationException("The codec is not configured.");
}
if (ret != (int)MediaCodecErrorCode.None)
{
throw new InvalidOperationException("Operation failed.");
}
MultimediaDebug.AssertNoError(ret);
}
/// <summary>
/// Adds the packet to the internal queue of the codec.
/// </summary>
/// <param name="packet">The packet to be encoded or decoded.</param>
/// <exception cref="ArgumentNullException"><paramref name="packet"/> is null.</exception>
/// <exception cref="InvalidOperationException">The current codec is not prepared yet.</exception>
/// <remarks>Any attempts to modify the packet will fail until the <see cref="InputProcessed"/> event for the packet is invoked.</remarks>
/// <since_tizen> 3 </since_tizen>
public void ProcessInput(MediaPacket packet)
{
ValidateNotDisposed();
if (packet == null)
{
throw new ArgumentNullException(nameof(packet));
}
MediaPacket.Lock packetLock = MediaPacket.Lock.Get(packet);
int ret = Interop.MediaCodec.Process(_handle, packetLock.GetHandle(), 0);
if (ret == (int)MediaCodecErrorCode.InvalidState)
{
throw new InvalidOperationException("The codec is in invalid state.");
}
MultimediaDebug.AssertNoError(ret);
}
private void RegisterInputProcessed()
{
_inputBufferUsedCb = (lockedPacketHandle, _) =>
{
MediaPacket packet = null;
// Lock must be disposed here, note that the packet won't be disposed.
using (MediaPacket.Lock packetLock =
MediaPacket.Lock.FromHandle(lockedPacketHandle))
{
Debug.Assert(packetLock != null);
packet = packetLock.MediaPacket;
}
Debug.Assert(packet != null);
InputProcessed?.Invoke(this, new InputProcessedEventArgs(packet));
};
int ret = Interop.MediaCodec.SetInputBufferUsedCb(_handle, _inputBufferUsedCb);
MultimediaDebug.AssertNoError(ret);
}
private void UnregisterOutputAvailableCallback()
{
int ret = Interop.MediaCodec.UnsetOutputBufferAvailableCb(_handle);
MultimediaDebug.AssertNoError(ret);
}
