@@ -279,6 +279,7 @@ Codecs:

   vc2*                                  Rostislav Pehlivanov

   vcr1.c                                Michael Niedermayer

   vda_h264_dec.c                        Xidorn Quan

+  videotoolboxenc.c                     Rick Kern

   vima.c                                Paul B Mahol

   vmnc.c                                Kostya Shishkov

   vorbisdec.c                           Denes Balatoni, David Conrad

@@ -155,7 +155,6 @@ Hardware accelerators:

   --disable-vaapi          disable VAAPI code [autodetect]

   --disable-vda            disable VDA code [autodetect]

   --disable-vdpau          disable VDPAU code [autodetect]

-  --enable-videotoolbox    enable VideoToolbox code [autodetect]

 Individual component options:

   --disable-everything     disable all components listed below

@@ -289,6 +288,7 @@ External library support:

   --disable-sdl            disable sdl [autodetect]

   --disable-securetransport disable Secure Transport, needed for TLS support

                            on OSX if openssl and gnutls are not used [autodetect]

+  --disable-videotoolbox   disable VideoToolbox code [autodetect]

   --enable-x11grab         enable X11 grabbing (legacy) [no]

   --disable-xlib           disable xlib [autodetect]

   --disable-zlib           disable zlib [autodetect]

@@ -1509,6 +1509,7 @@ EXTERNAL_LIBRARY_LIST="

     schannel

     sdl

     securetransport

+    videotoolbox

     x11grab

     xlib

     zlib

@@ -1540,7 +1541,7 @@ HWACCEL_LIST="

     vaapi

     vda

     vdpau

-    videotoolbox

+    videotoolbox_hwaccel

     xvmc

 "

@@ -2484,11 +2485,13 @@ crystalhd_deps="libcrystalhd_libcrystalhd_if_h"

 d3d11va_deps="d3d11_h dxva_h ID3D11VideoDecoder ID3D11VideoContext"

 dxva2_deps="dxva2api_h DXVA2_ConfigPictureDecode"

 vaapi_deps="va_va_h"

-vda_deps="VideoDecodeAcceleration_VDADecoder_h pthreads"

-vda_extralibs="-framework CoreFoundation -framework VideoDecodeAcceleration -framework QuartzCore"

+vda_framework_deps="VideoDecodeAcceleration_VDADecoder_h"

+vda_framework_extralibs="-framework VideoDecodeAcceleration"

+vda_deps="vda_framework pthreads"

+vda_extralibs="-framework CoreFoundation -framework QuartzCore"

 vdpau_deps="vdpau_vdpau_h vdpau_vdpau_x11_h"

-videotoolbox_deps="VideoToolbox_VideoToolbox_h pthreads"

-videotoolbox_extralibs="-framework CoreFoundation -framework VideoToolbox -framework CoreMedia -framework QuartzCore -framework CoreVideo"

+videotoolbox_hwaccel_deps="videotoolbox pthreads"

+videotoolbox_hwaccel_extralibs="-framework QuartzCore"

 xvmc_deps="X11_extensions_XvMClib_h"

 h263_vaapi_hwaccel_deps="vaapi"

@@ -2611,6 +2614,8 @@ mjpeg2jpeg_bsf_select="jpegtables"

 # external libraries

 chromaprint_muxer_deps="chromaprint"

+h264_videotoolbox_encoder_deps="videotoolbox_encoder pthreads"

+h264_videotoolbox_encoder_select="bzlib zlib iconv"

 libcelt_decoder_deps="libcelt"

 libdcadec_decoder_deps="libdcadec"

 libfaac_encoder_deps="libfaac"

@@ -2672,6 +2677,10 @@ libzvbi_teletext_decoder_deps="libzvbi"

 nvenc_encoder_deps="nvenc"

 nvenc_h264_encoder_deps="nvenc"

 nvenc_hevc_encoder_deps="nvenc"

+videotoolbox_deps="VideoToolbox_VideoToolbox_h"

+videotoolbox_extralibs="-framework CoreFoundation -framework VideoToolbox -framework CoreMedia -framework CoreVideo"

+videotoolbox_encoder_deps="videotoolbox VTCompressionSessionPrepareToEncodeFrames"

+videotoolbox_encoder_suggest="vda_framework"

 # demuxers / muxers

 ac3_demuxer_select="ac3_parser"

@@ -3052,9 +3061,11 @@ sws_max_filter_size_default=256

 set_default sws_max_filter_size

 # Enable hwaccels by default.

-enable d3d11va dxva2 vaapi vda vdpau videotoolbox xvmc

+enable d3d11va dxva2 vaapi vda vdpau videotoolbox_hwaccel xvmc

 enable xlib

+enable vda_framework videotoolbox videotoolbox_encoder

+

 # build settings

 SHFLAGS='-shared -Wl,-soname,$$(@F)'

 LIBPREF="lib"

@@ -5449,6 +5460,7 @@ check_header vdpau/vdpau.h

 check_header vdpau/vdpau_x11.h

 check_header VideoDecodeAcceleration/VDADecoder.h

 check_header VideoToolbox/VideoToolbox.h

+check_func_headers VideoToolbox/VTCompressionSession.h VTCompressionSessionPrepareToEncodeFrames -framework VideoToolbox

 check_header windows.h

 check_header X11/extensions/XvMClib.h

 check_header asm/types.h

@@ -69,6 +69,7 @@ OBJS-$(CONFIG_H264CHROMA)              += h264chroma.o

 OBJS-$(CONFIG_H264DSP)                 += h264dsp.o h264idct.o

 OBJS-$(CONFIG_H264PRED)                += h264pred.o

 OBJS-$(CONFIG_H264QPEL)                += h264qpel.o

+OBJS-$(CONFIG_H264_VIDEOTOOLBOX_ENCODER) += videotoolboxenc.o

 OBJS-$(CONFIG_HPELDSP)                 += hpeldsp.o

 OBJS-$(CONFIG_HUFFMAN)                 += huffman.o

 OBJS-$(CONFIG_HUFFYUVDSP)              += huffyuvdsp.o

@@ -604,6 +604,7 @@ void avcodec_register_all(void)

      * above is available */

     REGISTER_ENCODER(LIBOPENH264,       libopenh264);

     REGISTER_ENCODER(H264_QSV,          h264_qsv);

+    REGISTER_ENCODER(H264_VIDEOTOOLBOX, h264_videotoolbox);

     REGISTER_ENCODER(NVENC,             nvenc);

     REGISTER_ENCODER(NVENC_H264,        nvenc_h264);

     REGISTER_ENCODER(NVENC_HEVC,        nvenc_hevc);

new file mode 100644

@@ -0,0 +1,1339 @@

+/*

+ * copyright (c) 2015 Rick Kern <kernrj@gmail.com>

+ *

+ * This file is part of FFmpeg.

+ *

+ * FFmpeg is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation; either

+ * version 2.1 of the License, or (at your option) any later version.

+ *

+ * FFmpeg is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with FFmpeg; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

+ */

+

+#include <VideoToolbox/VideoToolbox.h>

+#include <CoreVideo/CoreVideo.h>

+#include <CoreMedia/CoreMedia.h>

+#include <TargetConditionals.h>

+#include <Availability.h>

+#include "avcodec.h"

+#include "libavutil/opt.h"

+#include "libavutil/avassert.h"

+#include "libavutil/atomic.h"

+#include "libavutil/avstring.h"

+#include "libavcodec/avcodec.h"

+#include "internal.h"

+#include <pthread.h>

+

+typedef enum VT_H264Profile {

+    H264_PROF_AUTO,

+    H264_PROF_BASELINE,

+    H264_PROF_MAIN,

+    H264_PROF_HIGH,

+    H264_PROF_COUNT

+} VT_H264Profile;

+

+static const uint8_t start_code[] = { 0, 0, 0, 1 };

+

+typedef struct BufNode {

+    CMSampleBufferRef cm_buffer;

+    struct BufNode* next;

+    int error;

+} BufNode;

+

+typedef struct VTEncContext {

+    AVClass *class;

+    VTCompressionSessionRef session;

+

+    pthread_mutex_t lock;

+    pthread_cond_t  cv_sample_sent;

+

+    int async_error;

+

+    BufNode *q_head;

+    BufNode *q_tail;

+

+    int64_t frame_ct_out;

+    int64_t frame_ct_in;

+

+    int64_t first_pts;

+    int64_t dts_delta;

+

+    int64_t profile;

+    int64_t level;

+

+    bool flushing;

+    bool has_b_frames;

+    bool warned_color_range;

+} VTEncContext;

+

+static void set_async_error(VTEncContext *vtctx, int err)

+{

+    BufNode *info;

+

+    pthread_mutex_lock(&vtctx->lock);

+

+    vtctx->async_error = err;

+

+    info = vtctx->q_head;

+    vtctx->q_head = vtctx->q_tail = NULL;

+

+    while (info) {

+        BufNode *next = info->next;

+        CFRelease(info->cm_buffer);

+        av_free(info);

+        info = next;

+    }

+

+    pthread_mutex_unlock(&vtctx->lock);

+}

+

+static int vtenc_q_pop(VTEncContext *vtctx, bool wait, CMSampleBufferRef *buf)

+{

+    BufNode *info;

+

+    pthread_mutex_lock(&vtctx->lock);

+

+    if (vtctx->async_error) {

+        pthread_mutex_unlock(&vtctx->lock);

+        return vtctx->async_error;

+    }

+

+    if (vtctx->flushing && vtctx->frame_ct_in == vtctx->frame_ct_out) {

+        *buf = NULL;

+

+        pthread_mutex_unlock(&vtctx->lock);

+        return 0;

+    }

+

+    while (!vtctx->q_head && !vtctx->async_error && wait) {

+        pthread_cond_wait(&vtctx->cv_sample_sent, &vtctx->lock);

+    }

+

+    if (!vtctx->q_head) {

+        pthread_mutex_unlock(&vtctx->lock);

+        *buf = NULL;

+        return 0;

+    }

+

+    info = vtctx->q_head;

+    vtctx->q_head = vtctx->q_head->next;

+    if (!vtctx->q_head) {

+        vtctx->q_tail = NULL;

+    }

+

+    pthread_mutex_unlock(&vtctx->lock);

+

+    *buf = info->cm_buffer;

+    av_free(info);

+

+    vtctx->frame_ct_out++;

+

+    return 0;

+}

+

+static void vtenc_q_push(VTEncContext *vtctx, CMSampleBufferRef buffer)

+{

+    BufNode *info = av_malloc(sizeof(BufNode));

+    if (!info) {

+        set_async_error(vtctx, AVERROR(ENOMEM));

+        return;

+    }

+

+    CFRetain(buffer);

+    info->cm_buffer = buffer;

+    info->next = NULL;

+

+    pthread_mutex_lock(&vtctx->lock);

+    pthread_cond_signal(&vtctx->cv_sample_sent);

+

+    if (!vtctx->q_head) {

+        vtctx->q_head = info;

+    } else {

+        vtctx->q_tail->next = info;

+    }

+

+    vtctx->q_tail = info;

+

+    pthread_mutex_unlock(&vtctx->lock);

+}

+

+static CMVideoCodecType get_cm_codec_type(enum AVCodecID id)

+{

+    switch (id) {

+    case AV_CODEC_ID_H264: return kCMVideoCodecType_H264;

+    default:               return 0;

+    }

+}

+

+static void vtenc_free_block(void *opaque, uint8_t *data)

+{

+    CMBlockBufferRef block = opaque;

+    CFRelease(block);

+}

+

+/**

+ * Get the parameter sets from a CMSampleBufferRef.

+ * @param dst If *dst isn't NULL, the parameters are copied into existing

+ *            memory. *dst_size must be set accordingly when *dst != NULL.

+ *            If *dst is NULL, it will be allocated.

+ *            In all cases, *dst_size is set to the number of bytes used starting

+ *            at *dst.

+ */

+static int get_params_size(

+    AVCodecContext              *avctx,

+    CMVideoFormatDescriptionRef vid_fmt,

+    size_t                      *size)

+{

+    size_t total_size = 0;

+    size_t ps_count;

+    size_t i;

+    int status;

+    status = CMVideoFormatDescriptionGetH264ParameterSetAtIndex(vid_fmt,

+                                                                0,

+                                                                NULL,

+                                                                NULL,

+                                                                &ps_count,

+                                                                NULL);

+    if (status) {

+        av_log(avctx, AV_LOG_ERROR, "Error getting parameter set count: %d\n", status);

+        return AVERROR_EXTERNAL;

+    }

+

+    for(i = 0; i < ps_count; i++){

+        const uint8_t *ps;

+        size_t ps_size;

+        status = CMVideoFormatDescriptionGetH264ParameterSetAtIndex(vid_fmt,

+                                                                    i,

+                                                                    &ps,

+                                                                    &ps_size,

+                                                                    NULL,

+                                                                    NULL);

+        if(status){

+            av_log(avctx, AV_LOG_ERROR, "Error getting parameter set size for index %zd: %d\n", i, status);

+            return AVERROR_EXTERNAL;

+        }

+

+        total_size += ps_size + sizeof(start_code);

+    }

+

+    *size = total_size;

+    return 0;

+}

+

+static int copy_param_sets(

+    AVCodecContext              *avctx,

+    CMVideoFormatDescriptionRef vid_fmt,

+    uint8_t                     *dst,

+    size_t                      dst_size)

+{

+    size_t ps_count;

+    int status;

+    size_t offset = 0;

+    size_t i;

+

+    status = CMVideoFormatDescriptionGetH264ParameterSetAtIndex(vid_fmt,

+                                                                0,

+                                                                NULL,

+                                                                NULL,

+                                                                &ps_count,

+                                                                NULL);

+    if (status) {

+        av_log(avctx, AV_LOG_ERROR, "Error getting parameter set count for copying: %d\n", status);

+        return AVERROR_EXTERNAL;

+    }

+

+    for (i = 0; i < ps_count; i++) {

+        const uint8_t *ps;

+        size_t ps_size;

+        size_t next_offset;

+

+        status = CMVideoFormatDescriptionGetH264ParameterSetAtIndex(vid_fmt,

+                                                                    i,

+                                                                    &ps,

+                                                                    &ps_size,

+                                                                    NULL,

+                                                                    NULL);

+        if (status) {

+            av_log(avctx, AV_LOG_ERROR, "Error getting parameter set data for index %zd: %d\n", i, status);

+            return AVERROR_EXTERNAL;

+        }

+

+        next_offset = offset + sizeof(start_code) + ps_size;

+        if (dst_size < next_offset) {

+            av_log(avctx, AV_LOG_ERROR, "Error: buffer too small for parameter sets.\n");

+            return AVERROR_BUFFER_TOO_SMALL;

+        }

+

+        memcpy(dst + offset, start_code, sizeof(start_code));

+        offset += sizeof(start_code);

+

+        memcpy(dst + offset, ps, ps_size);

+        offset = next_offset;

+    }

+

+    return 0;

+}

+

+static int set_extradata(AVCodecContext *avctx, CMSampleBufferRef sample_buffer)

+{

+    CMVideoFormatDescriptionRef vid_fmt;

+    size_t total_size;

+    int status;

+

+    vid_fmt = CMSampleBufferGetFormatDescription(sample_buffer);

+    if (!vid_fmt) {

+        av_log(avctx, AV_LOG_ERROR, "No video format.\n");

+        return AVERROR_EXTERNAL;

+    }

+

+    status = get_params_size(avctx, vid_fmt, &total_size);

+    if (status) {

+        av_log(avctx, AV_LOG_ERROR, "Could not get parameter sets.\n");

+        return status;

+    }

+

+    avctx->extradata = av_malloc(total_size);

+    if (!avctx->extradata) {

+        return AVERROR(ENOMEM);

+    }

+    avctx->extradata_size = total_size;

+

+    status = copy_param_sets(avctx, vid_fmt, avctx->extradata, total_size);

+

+    if (status) {

+        av_log(avctx, AV_LOG_ERROR, "Could not copy param sets.\n");

+        return status;

+    }

+

+    return 0;

+}

+

+static void vtenc_output_callback(

+    void *CM_NULLABLE ctx,

+    void *sourceFrameCtx,

+    OSStatus status,

+    VTEncodeInfoFlags flags,

+    CM_NULLABLE CMSampleBufferRef sample_buffer)

+{

+    AVCodecContext *avctx = ctx;

+    VTEncContext   *vtctx = avctx->priv_data;

+

+    if (vtctx->async_error) {

+        if(sample_buffer) CFRelease(sample_buffer);

+        return;

+    }

+

+    if (status || !sample_buffer) {

+        av_log(avctx, AV_LOG_ERROR, "Error encoding frame: %d\n", (int)status);

+        set_async_error(vtctx, AVERROR_EXTERNAL);

+        return;

+    }

+

+    if (!avctx->extradata && (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER)) {

+        int set_status = set_extradata(avctx, sample_buffer);

+        if (set_status) {

+            set_async_error(vtctx, set_status);

+            return;

+        }

+    }

+

+    vtenc_q_push(vtctx, sample_buffer);

+}

+

+static int get_length_code_size(

+    AVCodecContext    *avctx,

+    CMSampleBufferRef sample_buffer,

+    size_t            *size)

+{

+    CMVideoFormatDescriptionRef vid_fmt;

+    int isize;

+    int status;

+

+    vid_fmt = CMSampleBufferGetFormatDescription(sample_buffer);

+    if (!vid_fmt) {

+        av_log(avctx, AV_LOG_ERROR, "Error getting buffer format description.\n");

+        return AVERROR_EXTERNAL;

+    }

+

+    status = CMVideoFormatDescriptionGetH264ParameterSetAtIndex(vid_fmt,

+                                                                0,

+                                                                NULL,

+                                                                NULL,

+                                                                NULL,

+                                                                &isize);

+    if (status) {

+        av_log(avctx, AV_LOG_ERROR, "Error getting length code size: %d\n", status);

+        return AVERROR_EXTERNAL;

+    }

+

+    *size = isize;

+    return 0;

+}

+

+/*

+ * Returns true on success.

+ *

+ * If profile_level_val is NULL and this method returns true, don't specify the

+ * profile/level to the encoder.

+ */

+static bool get_vt_profile_level(AVCodecContext *avctx,

+                                 CFStringRef    *profile_level_val)

+{

+    VTEncContext *vtctx = avctx->priv_data;

+    int64_t profile = vtctx->profile;

+

+    if (profile == H264_PROF_AUTO && vtctx->level) {

+        //Need to pick a profile if level is not auto-selected.

+        profile = vtctx->has_b_frames ? H264_PROF_MAIN : H264_PROF_BASELINE;

+    }

+

+    *profile_level_val = NULL;

+

+    switch (profile) {

+        case H264_PROF_AUTO:

+            return true;

+

+        case H264_PROF_BASELINE:

+            switch (vtctx->level) {

+                case  0: *profile_level_val = kVTProfileLevel_H264_Baseline_AutoLevel; break;

+                case 13: *profile_level_val = kVTProfileLevel_H264_Baseline_1_3;       break;

+                case 30: *profile_level_val = kVTProfileLevel_H264_Baseline_3_0;       break;

+                case 31: *profile_level_val = kVTProfileLevel_H264_Baseline_3_1;       break;

+                case 32: *profile_level_val = kVTProfileLevel_H264_Baseline_3_2;       break;

+                case 40: *profile_level_val = kVTProfileLevel_H264_Baseline_4_0;       break;

+                case 41: *profile_level_val = kVTProfileLevel_H264_Baseline_4_1;       break;

+                case 42: *profile_level_val = kVTProfileLevel_H264_Baseline_4_2;       break;

+                case 50: *profile_level_val = kVTProfileLevel_H264_Baseline_5_0;       break;

+                case 51: *profile_level_val = kVTProfileLevel_H264_Baseline_5_1;       break;

+                case 52: *profile_level_val = kVTProfileLevel_H264_Baseline_5_2;       break;

+            }

+            break;

+

+        case H264_PROF_MAIN:

+            switch (vtctx->level) {

+                case  0: *profile_level_val = kVTProfileLevel_H264_Main_AutoLevel; break;

+                case 30: *profile_level_val = kVTProfileLevel_H264_Main_3_0;       break;

+                case 31: *profile_level_val = kVTProfileLevel_H264_Main_3_1;       break;

+                case 32: *profile_level_val = kVTProfileLevel_H264_Main_3_2;       break;

+                case 40: *profile_level_val = kVTProfileLevel_H264_Main_4_0;       break;

+                case 41: *profile_level_val = kVTProfileLevel_H264_Main_4_1;       break;

+                case 42: *profile_level_val = kVTProfileLevel_H264_Main_4_2;       break;

+                case 50: *profile_level_val = kVTProfileLevel_H264_Main_5_0;       break;

+                case 51: *profile_level_val = kVTProfileLevel_H264_Main_5_1;       break;

+                case 52: *profile_level_val = kVTProfileLevel_H264_Main_5_2;       break;

+            }

+            break;

+

+        case H264_PROF_HIGH:

+            switch (vtctx->level) {

+                case  0: *profile_level_val = kVTProfileLevel_H264_High_AutoLevel; break;

+                case 30: *profile_level_val = kVTProfileLevel_H264_High_3_0;       break;

+                case 31: *profile_level_val = kVTProfileLevel_H264_High_3_1;       break;

+                case 32: *profile_level_val = kVTProfileLevel_H264_High_3_2;       break;

+                case 40: *profile_level_val = kVTProfileLevel_H264_High_4_0;       break;

+                case 41: *profile_level_val = kVTProfileLevel_H264_High_4_1;       break;

+                case 42: *profile_level_val = kVTProfileLevel_H264_High_4_2;       break;

+                case 50: *profile_level_val = kVTProfileLevel_H264_High_5_0;       break;

+                case 51: *profile_level_val = kVTProfileLevel_H264_High_5_1;       break;

+                case 52: *profile_level_val = kVTProfileLevel_H264_High_5_2;       break;

+            }

+            break;

+    }

+

+    if (!*profile_level_val) {

+        av_log(avctx, AV_LOG_ERROR, "Invalid Profile/Level.\n");

+        return false;

+    }

+

+    return true;

+}

+

+static av_cold int vtenc_init(AVCodecContext *avctx)

+{

+    CFMutableDictionaryRef enc_info;

+    CMVideoCodecType       codec_type;

+    VTEncContext           *vtctx = avctx->priv_data;

+    CFStringRef            profile_level;

+    SInt32                 bit_rate = avctx->bit_rate;

+    CFNumberRef            bit_rate_num;

+    int                    status;

+

+    codec_type = get_cm_codec_type(avctx->codec_id);

+    if (!codec_type) {

+        av_log(avctx, AV_LOG_ERROR, "Error: no mapping for AVCodecID %d\n", avctx->codec_id);

+        return AVERROR(EINVAL);

+    }

+

+    vtctx->has_b_frames = avctx->has_b_frames || avctx->max_b_frames > 0;

+    if(vtctx->has_b_frames && vtctx->profile == H264_PROF_BASELINE){

+        av_log(avctx, AV_LOG_WARNING, "Cannot use B-frames with baseline profile. Output will not contain B-frames.\n");

+        vtctx->has_b_frames = false;

+    }

+

+    if (!get_vt_profile_level(avctx, &profile_level)) return AVERROR(EINVAL);

+

+    vtctx->session = NULL;

+

+    enc_info = CFDictionaryCreateMutable(

+        kCFAllocatorDefault,

+        20,

+        &kCFCopyStringDictionaryKeyCallBacks,

+        &kCFTypeDictionaryValueCallBacks

+    );

+

+    if (!enc_info) return AVERROR(ENOMEM);

+

+#if !TARGET_OS_IPHONE

+    CFDictionarySetValue(enc_info, kVTVideoEncoderSpecification_RequireHardwareAcceleratedVideoEncoder, kCFBooleanTrue);

+    CFDictionarySetValue(enc_info, kVTVideoEncoderSpecification_EnableHardwareAcceleratedVideoEncoder,  kCFBooleanTrue);

+#endif

+

+    status = VTCompressionSessionCreate(

+        kCFAllocatorDefault,

+        avctx->width,

+        avctx->height,

+        codec_type,

+        enc_info,

+        NULL,

+        kCFAllocatorDefault,

+        vtenc_output_callback,

+        avctx,

+        &vtctx->session

+    );

+

+#if !TARGET_OS_IPHONE

+    if (status != 0 || !vtctx->session) {

+        CFDictionaryRemoveValue(enc_info, kVTVideoEncoderSpecification_RequireHardwareAcceleratedVideoEncoder);

+

+        status = VTCompressionSessionCreate(

+            kCFAllocatorDefault,

+            avctx->width,

+            avctx->height,

+            codec_type,

+            enc_info,

+            NULL,

+            kCFAllocatorDefault,

+            vtenc_output_callback,

+            avctx,

+            &vtctx->session

+        );

+    }

+#endif

+

+    CFRelease(enc_info);

+

+    if (status || !vtctx->session) {

+        av_log(avctx, AV_LOG_ERROR, "Error: cannot create compression session: %d\n", status);

+        return AVERROR_EXTERNAL;

+    }

+

+    bit_rate_num = CFNumberCreate(kCFAllocatorDefault,

+                                  kCFNumberSInt32Type,

+                                  &bit_rate);

+    if (!bit_rate_num) return AVERROR(ENOMEM);

+

+    status = VTSessionSetProperty(vtctx->session,

+                                  kVTCompressionPropertyKey_AverageBitRate,

+                                  bit_rate_num);

+    CFRelease(bit_rate_num);

+

+    if (status) {

+        av_log(avctx, AV_LOG_ERROR, "Error setting bitrate property: %d\n", status);

+        return AVERROR_EXTERNAL;

+    }

+

+    if (profile_level) {

+        status = VTSessionSetProperty(vtctx->session,

+                                      kVTCompressionPropertyKey_ProfileLevel,

+                                      profile_level);

+        if (status) {

+            av_log(avctx, AV_LOG_ERROR, "Error setting profile/level property: %d\n", status);

+            return AVERROR_EXTERNAL;

+        }

+    }

+

+    if (avctx->gop_size > 0) {

+        CFNumberRef interval = CFNumberCreate(kCFAllocatorDefault,

+                                              kCFNumberIntType,

+                                              &avctx->gop_size);

+        status = VTSessionSetProperty(vtctx->session,

+                                      kVTCompressionPropertyKey_MaxKeyFrameInterval,

+                                      interval);

+

+        if (status) {

+            av_log(avctx, AV_LOG_ERROR, "Error setting 'max key-frame interval' property: %d\n", status);

+            return AVERROR_EXTERNAL;

+        }

+    }

+

+    if (!vtctx->has_b_frames) {

+        status = VTSessionSetProperty(vtctx->session,

+                                      kVTCompressionPropertyKey_AllowFrameReordering,

+                                      kCFBooleanFalse);

+

+        if (status) {

+            av_log(avctx, AV_LOG_ERROR, "Error setting 'allow frame reordering' property: %d\n", status);

+            return AVERROR_EXTERNAL;

+        }

+    }

+

+    status = VTCompressionSessionPrepareToEncodeFrames(vtctx->session);

+    if (status) {

+        av_log(avctx, AV_LOG_ERROR, "Error: cannot prepare encoder: %d\n", status);

+        return AVERROR_EXTERNAL;

+    }

+

+    pthread_mutex_init(&vtctx->lock, NULL);

+    pthread_cond_init(&vtctx->cv_sample_sent, NULL);

+    vtctx->dts_delta = vtctx->has_b_frames ? -1 : 0;

+

+    return 0;

+}

+

+static void vtenc_get_frame_info(CMSampleBufferRef buffer, bool *is_key_frame)

+{

+    CFArrayRef      attachments;

+    CFDictionaryRef attachment;

+    CFBooleanRef    not_sync;

+    CFIndex         len;

+

+    attachments = CMSampleBufferGetSampleAttachmentsArray(buffer, false);

+    len = !attachments ? 0 : CFArrayGetCount(attachments);

+

+    if (!len) {

+        *is_key_frame = true;

+        return;

+    }

+

+    attachment = CFArrayGetValueAtIndex(attachments, 0);

+

+    if (CFDictionaryGetValueIfPresent(attachment,

+                                      kCMSampleAttachmentKey_NotSync,

+                                      (const void **)&not_sync))

+    {

+        *is_key_frame = !CFBooleanGetValue(not_sync);

+    } else {

+        *is_key_frame = true;

+    }

+}

+

+/**

+ * Replaces length codes with H.264 Annex B start codes.

+ * length_code_size must equal sizeof(start_code).

+ * On failure, the contents of data may have been modified.

+ *

+ * @param length_code_size Byte length of each length code

+ * @param data Call with NAL units prefixed with length codes.

+ *             On success, the length codes are replace with

+ *             start codes.

+ * @param size Length of data, excluding any padding.

+ * @return 0 on success

+ *         AVERROR_BUFFER_TOO_SMALL if length code size is smaller

+ *         than a start code or if a length_code in data specifies

+ *         data beyond the end of its buffer.

+ */

+static int replace_length_codes(size_t  length_code_size,

+                                uint8_t *data,

+                                size_t  size)

+{

+    size_t remaining_size = size;

+

+    if (length_code_size != sizeof(start_code)) {

+        av_log(NULL, AV_LOG_ERROR, "Start code size and length code size not equal.\n");

+        return AVERROR_BUFFER_TOO_SMALL;

+    }

+

+    while (remaining_size > 0) {

+        size_t box_len = 0;

+        size_t i;

+

+        for (i = 0; i < length_code_size; i++) {

+            box_len <<= 8;

+            box_len |= data[i];

+        }

+

+        if (remaining_size < box_len + sizeof(start_code)) {

+            av_log(NULL, AV_LOG_ERROR, "Length is out of range.\n");

+            AVERROR_BUFFER_TOO_SMALL;

+        }

+

+        memcpy(data, start_code, sizeof(start_code));

+        data += box_len + sizeof(start_code);

+        remaining_size -= box_len + sizeof(start_code);

+    }

+

+    return 0;

+}

+

+/**

+ * Copies NAL units and replaces length codes with

+ * H.264 Annex B start codes. On failure, the contents of

+ * dst_data may have been modified.

+ *

+ * @param length_code_size Byte length of each length code

+ * @param src_data NAL units prefixed with length codes.

+ * @param src_size Length of buffer, excluding any padding.

+ * @param dst_data Must be zeroed before calling this function.

+ *                 Contains the copied NAL units prefixed with

+ *                 start codes when the function returns

+ *                 successfully.

+ * @param dst_size Length of dst_data

+ * @return 0 on success

+ *         AVERROR_INVALIDDATA if length_code_size is invalid

+ *         AVERROR_BUFFER_TOO_SMALL if dst_data is too small

+ *         or if a length_code in src_data specifies data beyond

+ *         the end of its buffer.

+ */

+static int copy_replace_length_codes(

+    size_t        length_code_size,

+    const uint8_t *src_data,

+    size_t        src_size,

+    uint8_t       *dst_data,

+    size_t        dst_size)

+{

+    size_t remaining_src_size = src_size;

+    size_t remaining_dst_size = dst_size;

+

+    if (length_code_size > 4) {

+        return AVERROR_INVALIDDATA;

+    }

+

+    while (remaining_src_size > 0) {

+        size_t curr_src_len;

+        size_t curr_dst_len;

+        size_t box_len = 0;

+        size_t i;

+

+        uint8_t       *dst_box;

+        const uint8_t *src_box;

+

+        for (i = 0; i < length_code_size; i++) {

+            box_len <<= 8;

+            box_len |= src_data[i];

+        }

+

+        curr_src_len = box_len + length_code_size;

+        curr_dst_len = box_len + sizeof(start_code);

+

+        if (remaining_src_size < curr_src_len) {

+            return AVERROR_BUFFER_TOO_SMALL;

+        }

+

+        if (remaining_dst_size < curr_dst_len) {

+            return AVERROR_BUFFER_TOO_SMALL;

+        }

+

+        dst_box = dst_data + sizeof(start_code);

+        src_box = src_data + length_code_size;

+

+        memcpy(dst_data, start_code, sizeof(start_code));

+        memcpy(dst_box,  src_box,    box_len);

+

+        src_data += curr_src_len;

+        dst_data += curr_dst_len;

+

+        remaining_src_size -= curr_src_len;

+        remaining_dst_size -= curr_dst_len;

+    }

+

+    return 0;

+}

+

+static int vtenc_cm_to_avpacket(

+    AVCodecContext    *avctx,

+    CMSampleBufferRef sample_buffer,

+    AVPacket          *pkt)

+{

+    VTEncContext *vtctx = avctx->priv_data;

+

+    int     status;

+    bool    is_key_frame;

+    bool    add_header;

+    char    *buf_data;

+    size_t  length_code_size;

+    size_t  header_size = 0;