#include "libavutil/avutil.h"
#include "libavutil/hwcontext.h"
#include "bytestream.h"
+#include "decode.h"
#include "h264dec.h"
#include "hevcdec.h"
#include "mpegvideo.h"
#ifndef kVTVideoDecoderSpecification_RequireHardwareAcceleratedVideoDecoder
# define kVTVideoDecoderSpecification_RequireHardwareAcceleratedVideoDecoder CFSTR("RequireHardwareAcceleratedVideoDecoder")
#endif
+#ifndef kVTVideoDecoderSpecification_EnableHardwareAcceleratedVideoDecoder
+# define kVTVideoDecoderSpecification_EnableHardwareAcceleratedVideoDecoder CFSTR("EnableHardwareAcceleratedVideoDecoder")
+#endif
#if !HAVE_KCMVIDEOCODECTYPE_HEVC
enum { kCMVideoCodecType_HEVC = 'hvc1' };
#define VIDEOTOOLBOX_ESDS_EXTRADATA_PADDING 12
+typedef struct VTHWFrame {
+ CVPixelBufferRef pixbuf;
+ AVBufferRef *hw_frames_ctx;
+} VTHWFrame;
+
static void videotoolbox_buffer_release(void *opaque, uint8_t *data)
{
- CVPixelBufferRef cv_buffer = (CVImageBufferRef)data;
- CVPixelBufferRelease(cv_buffer);
+ VTHWFrame *ref = (VTHWFrame *)data;
+ av_buffer_unref(&ref->hw_frames_ctx);
+ CVPixelBufferRelease(ref->pixbuf);
+
+ av_free(data);
}
static int videotoolbox_buffer_copy(VTContext *vtctx,
return 0;
}
+static int videotoolbox_postproc_frame(void *avctx, AVFrame *frame)
+{
+ VTHWFrame *ref = (VTHWFrame *)frame->buf[0]->data;
+
+ if (!ref->pixbuf) {
+ av_log(avctx, AV_LOG_ERROR, "No frame decoded?\n");
+ av_frame_unref(frame);
+ return AVERROR_EXTERNAL;
+ }
+
+ frame->data[3] = (uint8_t*)ref->pixbuf;
+
+ if (ref->hw_frames_ctx) {
+ av_buffer_unref(&frame->hw_frames_ctx);
+ frame->hw_frames_ctx = av_buffer_ref(ref->hw_frames_ctx);
+ if (!frame->hw_frames_ctx)
+ return AVERROR(ENOMEM);
+ }
+
+ return 0;
+}
+
int ff_videotoolbox_alloc_frame(AVCodecContext *avctx, AVFrame *frame)
{
+ size_t size = sizeof(VTHWFrame);
+ uint8_t *data = NULL;
+ AVBufferRef *buf = NULL;
+ int ret = ff_attach_decode_data(frame);
+ FrameDecodeData *fdd;
+ if (ret < 0)
+ return ret;
+
+ data = av_mallocz(size);
+ if (!data)
+ return AVERROR(ENOMEM);
+ buf = av_buffer_create(data, size, videotoolbox_buffer_release, NULL, 0);
+ if (!buf) {
+ av_freep(&data);
+ return AVERROR(ENOMEM);
+ }
+ frame->buf[0] = buf;
+
+ fdd = (FrameDecodeData*)frame->private_ref->data;
+ fdd->post_process = videotoolbox_postproc_frame;
+
frame->width = avctx->width;
frame->height = avctx->height;
frame->format = avctx->pix_fmt;
- frame->buf[0] = av_buffer_alloc(1);
-
- if (!frame->buf[0])
- return AVERROR(ENOMEM);
return 0;
}
CFDataRef ff_videotoolbox_avcc_extradata_create(AVCodecContext *avctx)
{
- H264Context *h = avctx->priv_data;
+ VTContext *vtctx = avctx->internal->hwaccel_priv_data;
+ H264Context *h = avctx->priv_data;
CFDataRef data = NULL;
uint8_t *p;
int vt_extradata_size = 6 + 2 + h->ps.sps->data_size + 3 + h->ps.pps->data_size;
p += 3 + h->ps.pps->data_size;
av_assert0(p - vt_extradata == vt_extradata_size);
+ // save sps header (profile/level) used to create decoder session,
+ // so we can detect changes and recreate it.
+ if (vtctx)
+ memcpy(vtctx->sps, h->ps.sps->data + 1, 3);
+
data = CFDataCreate(kCFAllocatorDefault, vt_extradata, vt_extradata_size);
av_free(vt_extradata);
return data;
return data;
}
-int ff_videotoolbox_buffer_create(VTContext *vtctx, AVFrame *frame)
+int ff_videotoolbox_h264_start_frame(AVCodecContext *avctx,
+ const uint8_t *buffer,
+ uint32_t size)
{
- av_buffer_unref(&frame->buf[0]);
-
- frame->buf[0] = av_buffer_create((uint8_t*)vtctx->frame,
- sizeof(vtctx->frame),
- videotoolbox_buffer_release,
- NULL,
- AV_BUFFER_FLAG_READONLY);
- if (!frame->buf[0]) {
- return AVERROR(ENOMEM);
- }
+ VTContext *vtctx = avctx->internal->hwaccel_priv_data;
+ H264Context *h = avctx->priv_data;
- frame->data[3] = (uint8_t*)vtctx->frame;
- vtctx->frame = NULL;
+ if (h->is_avc == 1) {
+ return videotoolbox_buffer_copy(vtctx, buffer, size);
+ }
return 0;
}
-int ff_videotoolbox_h264_start_frame(AVCodecContext *avctx,
- const uint8_t *buffer,
- uint32_t size)
+static int videotoolbox_h264_decode_params(AVCodecContext *avctx,
+ int type,
+ const uint8_t *buffer,
+ uint32_t size)
{
VTContext *vtctx = avctx->internal->hwaccel_priv_data;
- H264Context *h = avctx->priv_data;
+ H264Context *h = avctx->priv_data;
- vtctx->bitstream_size = 0;
+ // save sps header (profile/level) used to create decoder session
+ if (!vtctx->sps[0])
+ memcpy(vtctx->sps, h->ps.sps->data + 1, 3);
- if (h->is_avc == 1) {
- return videotoolbox_buffer_copy(vtctx, buffer, size);
+ if (type == H264_NAL_SPS) {
+ if (size > 4 && memcmp(vtctx->sps, buffer + 1, 3) != 0) {
+ vtctx->reconfig_needed = true;
+ memcpy(vtctx->sps, buffer + 1, 3);
+ }
}
- return 0;
+ // pass-through SPS/PPS changes to the decoder
+ return ff_videotoolbox_h264_decode_slice(avctx, buffer, size);
}
-int ff_videotoolbox_h264_decode_slice(AVCodecContext *avctx,
- const uint8_t *buffer,
- uint32_t size)
+static int videotoolbox_common_decode_slice(AVCodecContext *avctx,
+ const uint8_t *buffer,
+ uint32_t size)
{
VTContext *vtctx = avctx->internal->hwaccel_priv_data;
- H264Context *h = avctx->priv_data;
void *tmp;
- if (h->is_avc == 1)
- return 0;
-
tmp = av_fast_realloc(vtctx->bitstream,
&vtctx->allocated_size,
vtctx->bitstream_size+size+4);
return 0;
}
+int ff_videotoolbox_h264_decode_slice(AVCodecContext *avctx,
+ const uint8_t *buffer,
+ uint32_t size)
+{
+ H264Context *h = avctx->priv_data;
+
+ if (h->is_avc == 1)
+ return 0;
+
+ return videotoolbox_common_decode_slice(avctx, buffer, size);
+}
+
int ff_videotoolbox_uninit(AVCodecContext *avctx)
{
VTContext *vtctx = avctx->internal->hwaccel_priv_data;
int width = CVPixelBufferGetWidth(pixbuf);
int height = CVPixelBufferGetHeight(pixbuf);
AVHWFramesContext *cached_frames;
+ VTHWFrame *ref;
int ret;
- ret = ff_videotoolbox_buffer_create(vtctx, frame);
- if (ret < 0)
- return ret;
+ if (!frame->buf[0] || frame->data[3]) {
+ av_log(avctx, AV_LOG_ERROR, "videotoolbox: invalid state\n");
+ av_frame_unref(frame);
+ return AVERROR_EXTERNAL;
+ }
+
+ ref = (VTHWFrame *)frame->buf[0]->data;
+
+ if (ref->pixbuf)
+ CVPixelBufferRelease(ref->pixbuf);
+ ref->pixbuf = vtctx->frame;
+ vtctx->frame = NULL;
// Old API code path.
if (!vtctx->cached_hw_frames_ctx)
vtctx->cached_hw_frames_ctx = hw_frames_ctx;
}
- av_buffer_unref(&frame->hw_frames_ctx);
- frame->hw_frames_ctx = av_buffer_ref(vtctx->cached_hw_frames_ctx);
- if (!frame->hw_frames_ctx)
+ av_buffer_unref(&ref->hw_frames_ctx);
+ ref->hw_frames_ctx = av_buffer_ref(vtctx->cached_hw_frames_ctx);
+ if (!ref->hw_frames_ctx)
return AVERROR(ENOMEM);
return 0;
return status;
}
-static int videotoolbox_common_end_frame(AVCodecContext *avctx, AVFrame *frame)
-{
- int status;
- AVVideotoolboxContext *videotoolbox = videotoolbox_get_context(avctx);
- VTContext *vtctx = avctx->internal->hwaccel_priv_data;
-
- if (!videotoolbox->session || !vtctx->bitstream)
- return AVERROR_INVALIDDATA;
-
- status = videotoolbox_session_decode_frame(avctx);
-
- if (status) {
- av_log(avctx, AV_LOG_ERROR, "Failed to decode frame (%d)\n", status);
- return AVERROR_UNKNOWN;
- }
-
- if (!vtctx->frame)
- return AVERROR_UNKNOWN;
-
- return videotoolbox_buffer_create(avctx, frame);
-}
-
-static int videotoolbox_h264_end_frame(AVCodecContext *avctx)
-{
- H264Context *h = avctx->priv_data;
- AVFrame *frame = h->cur_pic_ptr->f;
-
- return videotoolbox_common_end_frame(avctx, frame);
-}
-
-static int videotoolbox_hevc_end_frame(AVCodecContext *avctx)
-{
- HEVCContext *h = avctx->priv_data;
- AVFrame *frame = h->ref->frame;
- VTContext *vtctx = avctx->internal->hwaccel_priv_data;
- int ret;
-
- ret = videotoolbox_common_end_frame(avctx, frame);
- vtctx->bitstream_size = 0;
- return ret;
-}
-
-static int videotoolbox_mpeg_start_frame(AVCodecContext *avctx,
- const uint8_t *buffer,
- uint32_t size)
-{
- VTContext *vtctx = avctx->internal->hwaccel_priv_data;
-
- return videotoolbox_buffer_copy(vtctx, buffer, size);
-}
-
-static int videotoolbox_mpeg_decode_slice(AVCodecContext *avctx,
- const uint8_t *buffer,
- uint32_t size)
-{
- return 0;
-}
-
-static int videotoolbox_mpeg_end_frame(AVCodecContext *avctx)
-{
- MpegEncContext *s = avctx->priv_data;
- AVFrame *frame = s->current_picture_ptr->f;
-
- return videotoolbox_common_end_frame(avctx, frame);
-}
-
-static CFDictionaryRef videotoolbox_decoder_config_create(CMVideoCodecType codec_type,
- AVCodecContext *avctx)
+static CMVideoFormatDescriptionRef videotoolbox_format_desc_create(CMVideoCodecType codec_type,
+ CFDictionaryRef decoder_spec,
+ int width,
+ int height)
{
- CFMutableDictionaryRef config_info = CFDictionaryCreateMutable(kCFAllocatorDefault,
- 0,
- &kCFTypeDictionaryKeyCallBacks,
- &kCFTypeDictionaryValueCallBacks);
-
- CFDictionarySetValue(config_info,
- kVTVideoDecoderSpecification_RequireHardwareAcceleratedVideoDecoder,
- kCFBooleanTrue);
-
- if (avctx->extradata_size) {
- CFMutableDictionaryRef avc_info;
- CFDataRef data = NULL;
-
- avc_info = CFDictionaryCreateMutable(kCFAllocatorDefault,
- 1,
- &kCFTypeDictionaryKeyCallBacks,
- &kCFTypeDictionaryValueCallBacks);
-
- switch (codec_type) {
- case kCMVideoCodecType_MPEG4Video :
- data = videotoolbox_esds_extradata_create(avctx);
- if (data)
- CFDictionarySetValue(avc_info, CFSTR("esds"), data);
- break;
- case kCMVideoCodecType_H264 :
- data = ff_videotoolbox_avcc_extradata_create(avctx);
- if (data)
- CFDictionarySetValue(avc_info, CFSTR("avcC"), data);
- break;
- case kCMVideoCodecType_HEVC :
- data = ff_videotoolbox_hvcc_extradata_create(avctx);
- if (data)
- CFDictionarySetValue(avc_info, CFSTR("hvcC"), data);
- break;
- default:
- break;
- }
+ CMFormatDescriptionRef cm_fmt_desc;
+ OSStatus status;
- CFDictionarySetValue(config_info,
- kCMFormatDescriptionExtension_SampleDescriptionExtensionAtoms,
- avc_info);
+ status = CMVideoFormatDescriptionCreate(kCFAllocatorDefault,
+ codec_type,
+ width,
+ height,
+ decoder_spec, // Dictionary of extension
+ &cm_fmt_desc);
- if (data)
- CFRelease(data);
+ if (status)
+ return NULL;
- CFRelease(avc_info);
- }
- return config_info;
+ return cm_fmt_desc;
}
static CFDictionaryRef videotoolbox_buffer_attributes_create(int width,
return buffer_attributes;
}
-static CMVideoFormatDescriptionRef videotoolbox_format_desc_create(CMVideoCodecType codec_type,
- CFDictionaryRef decoder_spec,
- int width,
- int height)
+static CFDictionaryRef videotoolbox_decoder_config_create(CMVideoCodecType codec_type,
+ AVCodecContext *avctx)
{
- CMFormatDescriptionRef cm_fmt_desc;
- OSStatus status;
+ CFMutableDictionaryRef config_info = CFDictionaryCreateMutable(kCFAllocatorDefault,
+ 0,
+ &kCFTypeDictionaryKeyCallBacks,
+ &kCFTypeDictionaryValueCallBacks);
- status = CMVideoFormatDescriptionCreate(kCFAllocatorDefault,
- codec_type,
- width,
- height,
- decoder_spec, // Dictionary of extension
- &cm_fmt_desc);
+ CFDictionarySetValue(config_info,
+ codec_type == kCMVideoCodecType_HEVC ?
+ kVTVideoDecoderSpecification_EnableHardwareAcceleratedVideoDecoder :
+ kVTVideoDecoderSpecification_RequireHardwareAcceleratedVideoDecoder,
+ kCFBooleanTrue);
- if (status)
- return NULL;
+ CFMutableDictionaryRef avc_info;
+ CFDataRef data = NULL;
- return cm_fmt_desc;
+ avc_info = CFDictionaryCreateMutable(kCFAllocatorDefault,
+ 1,
+ &kCFTypeDictionaryKeyCallBacks,
+ &kCFTypeDictionaryValueCallBacks);
+
+ switch (codec_type) {
+ case kCMVideoCodecType_MPEG4Video :
+ if (avctx->extradata_size)
+ data = videotoolbox_esds_extradata_create(avctx);
+ if (data)
+ CFDictionarySetValue(avc_info, CFSTR("esds"), data);
+ break;
+ case kCMVideoCodecType_H264 :
+ data = ff_videotoolbox_avcc_extradata_create(avctx);
+ if (data)
+ CFDictionarySetValue(avc_info, CFSTR("avcC"), data);
+ break;
+ case kCMVideoCodecType_HEVC :
+ data = ff_videotoolbox_hvcc_extradata_create(avctx);
+ if (data)
+ CFDictionarySetValue(avc_info, CFSTR("hvcC"), data);
+ break;
+ default:
+ break;
+ }
+
+ CFDictionarySetValue(config_info,
+ kCMFormatDescriptionExtension_SampleDescriptionExtensionAtoms,
+ avc_info);
+
+ if (data)
+ CFRelease(data);
+
+ CFRelease(avc_info);
+ return config_info;
}
-static int videotoolbox_default_init(AVCodecContext *avctx)
+static int videotoolbox_start(AVCodecContext *avctx)
{
AVVideotoolboxContext *videotoolbox = videotoolbox_get_context(avctx);
OSStatus status;
decoder_spec = videotoolbox_decoder_config_create(videotoolbox->cm_codec_type, avctx);
+ if (!decoder_spec) {
+ av_log(avctx, AV_LOG_ERROR, "decoder specification creation failed\n");
+ return -1;
+ }
+
videotoolbox->cm_fmt_desc = videotoolbox_format_desc_create(videotoolbox->cm_codec_type,
decoder_spec,
avctx->width,
case kVTVideoDecoderUnsupportedDataFormatErr:
av_log(avctx, AV_LOG_VERBOSE, "VideoToolbox does not support this format.\n");
return AVERROR(ENOSYS);
+ case kVTCouldNotFindVideoDecoderErr:
+ av_log(avctx, AV_LOG_VERBOSE, "VideoToolbox decoder for this format not found.\n");
+ return AVERROR(ENOSYS);
case kVTVideoDecoderMalfunctionErr:
av_log(avctx, AV_LOG_VERBOSE, "VideoToolbox malfunction.\n");
return AVERROR(EINVAL);
- case kVTVideoDecoderBadDataErr :
+ case kVTVideoDecoderBadDataErr:
av_log(avctx, AV_LOG_VERBOSE, "VideoToolbox reported invalid data.\n");
return AVERROR_INVALIDDATA;
case 0:
return 0;
default:
- av_log(avctx, AV_LOG_VERBOSE, "Unknown VideoToolbox session creation error %u\n", (unsigned)status);
+ av_log(avctx, AV_LOG_VERBOSE, "Unknown VideoToolbox session creation error %d\n", (int)status);
return AVERROR_UNKNOWN;
}
}
-static void videotoolbox_default_free(AVCodecContext *avctx)
+static void videotoolbox_stop(AVCodecContext *avctx)
{
AVVideotoolboxContext *videotoolbox = videotoolbox_get_context(avctx);
+ if (!videotoolbox)
+ return;
+
+ if (videotoolbox->cm_fmt_desc) {
+ CFRelease(videotoolbox->cm_fmt_desc);
+ videotoolbox->cm_fmt_desc = NULL;
+ }
+
+ if (videotoolbox->session) {
+ VTDecompressionSessionInvalidate(videotoolbox->session);
+ CFRelease(videotoolbox->session);
+ videotoolbox->session = NULL;
+ }
+}
+
+static const char *videotoolbox_error_string(OSStatus status)
+{
+ switch (status) {
+ case kVTVideoDecoderBadDataErr:
+ return "bad data";
+ case kVTVideoDecoderMalfunctionErr:
+ return "decoder malfunction";
+ case kVTInvalidSessionErr:
+ return "invalid session";
+ }
+ return "unknown";
+}
- if (videotoolbox) {
- if (videotoolbox->cm_fmt_desc)
- CFRelease(videotoolbox->cm_fmt_desc);
+static int videotoolbox_common_end_frame(AVCodecContext *avctx, AVFrame *frame)
+{
+ OSStatus status;
+ AVVideotoolboxContext *videotoolbox = videotoolbox_get_context(avctx);
+ VTContext *vtctx = avctx->internal->hwaccel_priv_data;
- if (videotoolbox->session) {
- VTDecompressionSessionInvalidate(videotoolbox->session);
- CFRelease(videotoolbox->session);
+ if (vtctx->reconfig_needed == true) {
+ vtctx->reconfig_needed = false;
+ av_log(avctx, AV_LOG_VERBOSE, "VideoToolbox decoder needs reconfig, restarting..\n");
+ videotoolbox_stop(avctx);
+ if (videotoolbox_start(avctx) != 0) {
+ return AVERROR_EXTERNAL;
}
}
+
+ if (!videotoolbox->session || !vtctx->bitstream || !vtctx->bitstream_size)
+ return AVERROR_INVALIDDATA;
+
+ status = videotoolbox_session_decode_frame(avctx);
+ if (status != noErr) {
+ if (status == kVTVideoDecoderMalfunctionErr || status == kVTInvalidSessionErr)
+ vtctx->reconfig_needed = true;
+ av_log(avctx, AV_LOG_ERROR, "Failed to decode frame (%s, %d)\n", videotoolbox_error_string(status), (int)status);
+ return AVERROR_UNKNOWN;
+ }
+
+ if (!vtctx->frame) {
+ vtctx->reconfig_needed = true;
+ return AVERROR_UNKNOWN;
+ }
+
+ return videotoolbox_buffer_create(avctx, frame);
+}
+
+static int videotoolbox_h264_end_frame(AVCodecContext *avctx)
+{
+ H264Context *h = avctx->priv_data;
+ AVFrame *frame = h->cur_pic_ptr->f;
+ VTContext *vtctx = avctx->internal->hwaccel_priv_data;
+ int ret = videotoolbox_common_end_frame(avctx, frame);
+ vtctx->bitstream_size = 0;
+ return ret;
+}
+
+static int videotoolbox_hevc_start_frame(AVCodecContext *avctx,
+ const uint8_t *buffer,
+ uint32_t size)
+{
+ return 0;
+}
+
+static int videotoolbox_hevc_decode_slice(AVCodecContext *avctx,
+ const uint8_t *buffer,
+ uint32_t size)
+{
+ return videotoolbox_common_decode_slice(avctx, buffer, size);
+}
+
+
+static int videotoolbox_hevc_decode_params(AVCodecContext *avctx,
+ int type,
+ const uint8_t *buffer,
+ uint32_t size)
+{
+ return videotoolbox_common_decode_slice(avctx, buffer, size);
+}
+
+static int videotoolbox_hevc_end_frame(AVCodecContext *avctx)
+{
+ HEVCContext *h = avctx->priv_data;
+ AVFrame *frame = h->ref->frame;
+ VTContext *vtctx = avctx->internal->hwaccel_priv_data;
+ int ret = videotoolbox_common_end_frame(avctx, frame);
+ vtctx->bitstream_size = 0;
+ return ret;
+}
+
+static int videotoolbox_mpeg_start_frame(AVCodecContext *avctx,
+ const uint8_t *buffer,
+ uint32_t size)
+{
+ VTContext *vtctx = avctx->internal->hwaccel_priv_data;
+
+ return videotoolbox_buffer_copy(vtctx, buffer, size);
+}
+
+static int videotoolbox_mpeg_decode_slice(AVCodecContext *avctx,
+ const uint8_t *buffer,
+ uint32_t size)
+{
+ return 0;
+}
+
+static int videotoolbox_mpeg_end_frame(AVCodecContext *avctx)
+{
+ MpegEncContext *s = avctx->priv_data;
+ AVFrame *frame = s->current_picture_ptr->f;
+
+ return videotoolbox_common_end_frame(avctx, frame);
}
static int videotoolbox_uninit(AVCodecContext *avctx)
ff_videotoolbox_uninit(avctx);
if (vtctx->vt_ctx)
- videotoolbox_default_free(avctx);
+ videotoolbox_stop(avctx);
av_buffer_unref(&vtctx->cached_hw_frames_ctx);
av_freep(&vtctx->vt_ctx);
goto fail;
}
- err = videotoolbox_default_init(avctx);
+ err = videotoolbox_start(avctx);
if (err < 0)
goto fail;
return err;
}
-AVHWAccel ff_h263_videotoolbox_hwaccel = {
+static int videotoolbox_frame_params(AVCodecContext *avctx,
+ AVBufferRef *hw_frames_ctx)
+{
+ AVHWFramesContext *frames_ctx = (AVHWFramesContext*)hw_frames_ctx->data;
+
+ frames_ctx->format = AV_PIX_FMT_VIDEOTOOLBOX;
+ frames_ctx->width = avctx->coded_width;
+ frames_ctx->height = avctx->coded_height;
+ frames_ctx->sw_format = AV_PIX_FMT_NV12;
+
+ return 0;
+}
+
+const AVHWAccel ff_h263_videotoolbox_hwaccel = {
.name = "h263_videotoolbox",
.type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_H263,
.start_frame = videotoolbox_mpeg_start_frame,
.decode_slice = videotoolbox_mpeg_decode_slice,
.end_frame = videotoolbox_mpeg_end_frame,
+ .frame_params = videotoolbox_frame_params,
.init = videotoolbox_common_init,
.uninit = videotoolbox_uninit,
.priv_data_size = sizeof(VTContext),
};
-AVHWAccel ff_hevc_videotoolbox_hwaccel = {
+const AVHWAccel ff_hevc_videotoolbox_hwaccel = {
.name = "hevc_videotoolbox",
.type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_HEVC,
.pix_fmt = AV_PIX_FMT_VIDEOTOOLBOX,
.alloc_frame = ff_videotoolbox_alloc_frame,
- .start_frame = ff_videotoolbox_h264_start_frame,
- .decode_slice = ff_videotoolbox_h264_decode_slice,
+ .start_frame = videotoolbox_hevc_start_frame,
+ .decode_slice = videotoolbox_hevc_decode_slice,
+ .decode_params = videotoolbox_hevc_decode_params,
.end_frame = videotoolbox_hevc_end_frame,
+ .frame_params = videotoolbox_frame_params,
.init = videotoolbox_common_init,
.uninit = ff_videotoolbox_uninit,
.priv_data_size = sizeof(VTContext),
};
-AVHWAccel ff_h264_videotoolbox_hwaccel = {
+const AVHWAccel ff_h264_videotoolbox_hwaccel = {
.name = "h264_videotoolbox",
.type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_H264,
.alloc_frame = ff_videotoolbox_alloc_frame,
.start_frame = ff_videotoolbox_h264_start_frame,
.decode_slice = ff_videotoolbox_h264_decode_slice,
+ .decode_params = videotoolbox_h264_decode_params,
.end_frame = videotoolbox_h264_end_frame,
+ .frame_params = videotoolbox_frame_params,
.init = videotoolbox_common_init,
.uninit = videotoolbox_uninit,
.priv_data_size = sizeof(VTContext),
};
-AVHWAccel ff_mpeg1_videotoolbox_hwaccel = {
+const AVHWAccel ff_mpeg1_videotoolbox_hwaccel = {
.name = "mpeg1_videotoolbox",
.type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_MPEG1VIDEO,
.start_frame = videotoolbox_mpeg_start_frame,
.decode_slice = videotoolbox_mpeg_decode_slice,
.end_frame = videotoolbox_mpeg_end_frame,
+ .frame_params = videotoolbox_frame_params,
.init = videotoolbox_common_init,
.uninit = videotoolbox_uninit,
.priv_data_size = sizeof(VTContext),
};
-AVHWAccel ff_mpeg2_videotoolbox_hwaccel = {
+const AVHWAccel ff_mpeg2_videotoolbox_hwaccel = {
.name = "mpeg2_videotoolbox",
.type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_MPEG2VIDEO,
.start_frame = videotoolbox_mpeg_start_frame,
.decode_slice = videotoolbox_mpeg_decode_slice,
.end_frame = videotoolbox_mpeg_end_frame,
+ .frame_params = videotoolbox_frame_params,
.init = videotoolbox_common_init,
.uninit = videotoolbox_uninit,
.priv_data_size = sizeof(VTContext),
};
-AVHWAccel ff_mpeg4_videotoolbox_hwaccel = {
+const AVHWAccel ff_mpeg4_videotoolbox_hwaccel = {
.name = "mpeg4_videotoolbox",
.type = AVMEDIA_TYPE_VIDEO,
.id = AV_CODEC_ID_MPEG4,
.start_frame = videotoolbox_mpeg_start_frame,
.decode_slice = videotoolbox_mpeg_decode_slice,
.end_frame = videotoolbox_mpeg_end_frame,
+ .frame_params = videotoolbox_frame_params,
.init = videotoolbox_common_init,
.uninit = videotoolbox_uninit,
.priv_data_size = sizeof(VTContext),
avctx->hwaccel_context = vtctx ?: av_videotoolbox_alloc_context();
if (!avctx->hwaccel_context)
return AVERROR(ENOMEM);
- return videotoolbox_default_init(avctx);
+ return videotoolbox_start(avctx);
}
void av_videotoolbox_default_free(AVCodecContext *avctx)
{
- videotoolbox_default_free(avctx);
+ videotoolbox_stop(avctx);
av_freep(&avctx->hwaccel_context);
}
#endif /* CONFIG_VIDEOTOOLBOX */