git.sesse.net Git - ffmpeg/blob - libavcodec/videotoolboxenc.c

   1 /*
   2  * copyright (c) 2015 Rick Kern <kernrj@gmail.com>
   3  *
   4  * This file is part of FFmpeg.
   5  *
   6  * FFmpeg is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * FFmpeg is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with FFmpeg; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #include <VideoToolbox/VideoToolbox.h>
  22 #include <CoreVideo/CoreVideo.h>
  23 #include <CoreMedia/CoreMedia.h>
  24 #include <TargetConditionals.h>
  25 #include <Availability.h>
  26 #include "avcodec.h"
  27 #include "libavutil/opt.h"
  28 #include "libavutil/avassert.h"
  29 #include "libavutil/atomic.h"
  30 #include "libavutil/avstring.h"
  31 #include "libavcodec/avcodec.h"
  32 #include "libavutil/pixdesc.h"
  33 #include "internal.h"
  34 #include <pthread.h>
  35
  36 #if !CONFIG_VT_BT2020
  37 # define kCVImageBufferColorPrimaries_ITU_R_2020   CFSTR("ITU_R_2020")
  38 # define kCVImageBufferTransferFunction_ITU_R_2020 CFSTR("ITU_R_2020")
  39 # define kCVImageBufferYCbCrMatrix_ITU_R_2020      CFSTR("ITU_R_2020")
  40 #endif
  41
  42 typedef enum VT_H264Profile {
  43     H264_PROF_AUTO,
  44     H264_PROF_BASELINE,
  45     H264_PROF_MAIN,
  46     H264_PROF_HIGH,
  47     H264_PROF_COUNT
  48 } VT_H264Profile;
  49
  50 typedef enum VTH264Entropy{
  51     VT_ENTROPY_NOT_SET,
  52     VT_CAVLC,
  53     VT_CABAC
  54 } VTH264Entropy;
  55
  56 static const uint8_t start_code[] = { 0, 0, 0, 1 };
  57
  58 typedef struct BufNode {
  59     CMSampleBufferRef cm_buffer;
  60     struct BufNode* next;
  61     int error;
  62 } BufNode;
  63
  64 typedef struct VTEncContext {
  65     AVClass *class;
  66     VTCompressionSessionRef session;
  67     CFStringRef ycbcr_matrix;
  68     CFStringRef color_primaries;
  69     CFStringRef transfer_function;
  70
  71     pthread_mutex_t lock;
  72     pthread_cond_t  cv_sample_sent;
  73
  74     int async_error;
  75
  76     BufNode *q_head;
  77     BufNode *q_tail;
  78
  79     int64_t frame_ct_out;
  80     int64_t frame_ct_in;
  81
  82     int64_t first_pts;
  83     int64_t dts_delta;
  84
  85     int64_t profile;
  86     int64_t level;
  87     int64_t entropy;
  88     int64_t realtime;
  89     int64_t frames_before;
  90     int64_t frames_after;
  91
  92     int64_t allow_sw;
  93
  94     bool flushing;
  95     bool has_b_frames;
  96     bool warned_color_range;
  97 } VTEncContext;
  98
  99 static int vtenc_populate_extradata(AVCodecContext   *avctx,
 100                                     CMVideoCodecType codec_type,
 101                                     CFStringRef      profile_level,
 102                                     CFNumberRef      gamma_level,
 103                                     CFDictionaryRef  enc_info,
 104                                     CFDictionaryRef  pixel_buffer_info);
 105
 106 /**
 107  * NULL-safe release of *refPtr, and sets value to NULL.
 108  */
 109 static void vt_release_num(CFNumberRef* refPtr){
 110     if (!*refPtr) {
 111         return;
 112     }
 113
 114     CFRelease(*refPtr);
 115     *refPtr = NULL;
 116 }
 117
 118 static void set_async_error(VTEncContext *vtctx, int err)
 119 {
 120     BufNode *info;
 121
 122     pthread_mutex_lock(&vtctx->lock);
 123
 124     vtctx->async_error = err;
 125
 126     info = vtctx->q_head;
 127     vtctx->q_head = vtctx->q_tail = NULL;
 128
 129     while (info) {
 130         BufNode *next = info->next;
 131         CFRelease(info->cm_buffer);
 132         av_free(info);
 133         info = next;
 134     }
 135
 136     pthread_mutex_unlock(&vtctx->lock);
 137 }
 138
 139 static int vtenc_q_pop(VTEncContext *vtctx, bool wait, CMSampleBufferRef *buf)
 140 {
 141     BufNode *info;
 142
 143     pthread_mutex_lock(&vtctx->lock);
 144
 145     if (vtctx->async_error) {
 146         pthread_mutex_unlock(&vtctx->lock);
 147         return vtctx->async_error;
 148     }
 149
 150     if (vtctx->flushing && vtctx->frame_ct_in == vtctx->frame_ct_out) {
 151         *buf = NULL;
 152
 153         pthread_mutex_unlock(&vtctx->lock);
 154         return 0;
 155     }
 156
 157     while (!vtctx->q_head && !vtctx->async_error && wait) {
 158         pthread_cond_wait(&vtctx->cv_sample_sent, &vtctx->lock);
 159     }
 160
 161     if (!vtctx->q_head) {
 162         pthread_mutex_unlock(&vtctx->lock);
 163         *buf = NULL;
 164         return 0;
 165     }
 166
 167     info = vtctx->q_head;
 168     vtctx->q_head = vtctx->q_head->next;
 169     if (!vtctx->q_head) {
 170         vtctx->q_tail = NULL;
 171     }
 172
 173     pthread_mutex_unlock(&vtctx->lock);
 174
 175     *buf = info->cm_buffer;
 176     av_free(info);
 177
 178     vtctx->frame_ct_out++;
 179
 180     return 0;
 181 }
 182
 183 static void vtenc_q_push(VTEncContext *vtctx, CMSampleBufferRef buffer)
 184 {
 185     BufNode *info = av_malloc(sizeof(BufNode));
 186     if (!info) {
 187         set_async_error(vtctx, AVERROR(ENOMEM));
 188         return;
 189     }
 190
 191     CFRetain(buffer);
 192     info->cm_buffer = buffer;
 193     info->next = NULL;
 194
 195     pthread_mutex_lock(&vtctx->lock);
 196     pthread_cond_signal(&vtctx->cv_sample_sent);
 197
 198     if (!vtctx->q_head) {
 199         vtctx->q_head = info;
 200     } else {
 201         vtctx->q_tail->next = info;
 202     }
 203
 204     vtctx->q_tail = info;
 205
 206     pthread_mutex_unlock(&vtctx->lock);
 207 }
 208
 209 static int count_nalus(size_t length_code_size,
 210                        CMSampleBufferRef sample_buffer,
 211                        int *count)
 212 {
 213     size_t offset = 0;
 214     int status;
 215     int nalu_ct = 0;
 216     uint8_t size_buf[4];
 217     size_t src_size = CMSampleBufferGetTotalSampleSize(sample_buffer);
 218     CMBlockBufferRef block = CMSampleBufferGetDataBuffer(sample_buffer);
 219
 220     if (length_code_size > 4)
 221         return AVERROR_INVALIDDATA;
 222
 223     while (offset < src_size) {
 224         size_t curr_src_len;
 225         size_t box_len = 0;
 226         size_t i;
 227
 228         status = CMBlockBufferCopyDataBytes(block,
 229                                             offset,
 230                                             length_code_size,
 231                                             size_buf);
 232
 233         for (i = 0; i < length_code_size; i++) {
 234             box_len <<= 8;
 235             box_len |= size_buf[i];
 236         }
 237
 238         curr_src_len = box_len + length_code_size;
 239         offset += curr_src_len;
 240
 241         nalu_ct++;
 242     }
 243
 244     *count = nalu_ct;
 245     return 0;
 246 }
 247
 248 static CMVideoCodecType get_cm_codec_type(enum AVCodecID id)
 249 {
 250     switch (id) {
 251     case AV_CODEC_ID_H264: return kCMVideoCodecType_H264;
 252     default:               return 0;
 253     }
 254 }
 255
 256 /**
 257  * Get the parameter sets from a CMSampleBufferRef.
 258  * @param dst If *dst isn't NULL, the parameters are copied into existing
 259  *            memory. *dst_size must be set accordingly when *dst != NULL.
 260  *            If *dst is NULL, it will be allocated.
 261  *            In all cases, *dst_size is set to the number of bytes used starting
 262  *            at *dst.
 263  */
 264 static int get_params_size(
 265     AVCodecContext              *avctx,
 266     CMVideoFormatDescriptionRef vid_fmt,
 267     size_t                      *size)
 268 {
 269     size_t total_size = 0;
 270     size_t ps_count;
 271     int is_count_bad = 0;
 272     size_t i;
 273     int status;
 274     status = CMVideoFormatDescriptionGetH264ParameterSetAtIndex(vid_fmt,
 275                                                                 0,
 276                                                                 NULL,
 277                                                                 NULL,
 278                                                                 &ps_count,
 279                                                                 NULL);
 280     if (status) {
 281         is_count_bad = 1;
 282         ps_count     = 0;
 283         status       = 0;
 284     }
 285
 286     for (i = 0; i < ps_count || is_count_bad; i++) {
 287         const uint8_t *ps;
 288         size_t ps_size;
 289         status = CMVideoFormatDescriptionGetH264ParameterSetAtIndex(vid_fmt,
 290                                                                     i,
 291                                                                     &ps,
 292                                                                     &ps_size,
 293                                                                     NULL,
 294                                                                     NULL);
 295         if (status) {
 296             /*
 297              * When ps_count is invalid, status != 0 ends the loop normally
 298              * unless we didn't get any parameter sets.
 299              */
 300             if (i > 0 && is_count_bad) status = 0;
 301
 302             break;
 303         }
 304
 305         total_size += ps_size + sizeof(start_code);
 306     }
 307
 308     if (status) {
 309         av_log(avctx, AV_LOG_ERROR, "Error getting parameter set sizes: %d\n", status);
 310         return AVERROR_EXTERNAL;
 311     }
 312
 313     *size = total_size;
 314     return 0;
 315 }
 316
 317 static int copy_param_sets(
 318     AVCodecContext              *avctx,
 319     CMVideoFormatDescriptionRef vid_fmt,
 320     uint8_t                     *dst,
 321     size_t                      dst_size)
 322 {
 323     size_t ps_count;
 324     int is_count_bad = 0;
 325     int status;
 326     size_t offset = 0;
 327     size_t i;
 328
 329     status = CMVideoFormatDescriptionGetH264ParameterSetAtIndex(vid_fmt,
 330                                                                 0,
 331                                                                 NULL,
 332                                                                 NULL,
 333                                                                 &ps_count,
 334                                                                 NULL);
 335     if (status) {
 336         is_count_bad = 1;
 337         ps_count     = 0;
 338         status       = 0;
 339     }
 340
 341
 342     for (i = 0; i < ps_count || is_count_bad; i++) {
 343         const uint8_t *ps;
 344         size_t ps_size;
 345         size_t next_offset;
 346
 347         status = CMVideoFormatDescriptionGetH264ParameterSetAtIndex(vid_fmt,
 348                                                                     i,
 349                                                                     &ps,
 350                                                                     &ps_size,
 351                                                                     NULL,
 352                                                                     NULL);
 353         if (status) {
 354             if (i > 0 && is_count_bad) status = 0;
 355
 356             break;
 357         }
 358
 359         next_offset = offset + sizeof(start_code) + ps_size;
 360         if (dst_size < next_offset) {
 361             av_log(avctx, AV_LOG_ERROR, "Error: buffer too small for parameter sets.\n");
 362             return AVERROR_BUFFER_TOO_SMALL;
 363         }
 364
 365         memcpy(dst + offset, start_code, sizeof(start_code));
 366         offset += sizeof(start_code);
 367
 368         memcpy(dst + offset, ps, ps_size);
 369         offset = next_offset;
 370     }
 371
 372     if (status) {
 373         av_log(avctx, AV_LOG_ERROR, "Error getting parameter set data: %d\n", status);
 374         return AVERROR_EXTERNAL;
 375     }
 376
 377     return 0;
 378 }
 379
 380 static int set_extradata(AVCodecContext *avctx, CMSampleBufferRef sample_buffer)
 381 {
 382     CMVideoFormatDescriptionRef vid_fmt;
 383     size_t total_size;
 384     int status;
 385
 386     vid_fmt = CMSampleBufferGetFormatDescription(sample_buffer);
 387     if (!vid_fmt) {
 388         av_log(avctx, AV_LOG_ERROR, "No video format.\n");
 389         return AVERROR_EXTERNAL;
 390     }
 391
 392     status = get_params_size(avctx, vid_fmt, &total_size);
 393     if (status) {
 394         av_log(avctx, AV_LOG_ERROR, "Could not get parameter sets.\n");
 395         return status;
 396     }
 397
 398     avctx->extradata = av_mallocz(total_size + AV_INPUT_BUFFER_PADDING_SIZE);
 399     if (!avctx->extradata) {
 400         return AVERROR(ENOMEM);
 401     }
 402     avctx->extradata_size = total_size;
 403
 404     status = copy_param_sets(avctx, vid_fmt, avctx->extradata, total_size);
 405
 406     if (status) {
 407         av_log(avctx, AV_LOG_ERROR, "Could not copy param sets.\n");
 408         return status;
 409     }
 410
 411     return 0;
 412 }
 413
 414 static void vtenc_output_callback(
 415     void *ctx,
 416     void *sourceFrameCtx,
 417     OSStatus status,
 418     VTEncodeInfoFlags flags,
 419     CMSampleBufferRef sample_buffer)
 420 {
 421     AVCodecContext *avctx = ctx;
 422     VTEncContext   *vtctx = avctx->priv_data;
 423
 424     if (vtctx->async_error) {
 425         if(sample_buffer) CFRelease(sample_buffer);
 426         return;
 427     }
 428
 429     if (status || !sample_buffer) {
 430         av_log(avctx, AV_LOG_ERROR, "Error encoding frame: %d\n", (int)status);
 431         set_async_error(vtctx, AVERROR_EXTERNAL);
 432         return;
 433     }
 434
 435     if (!avctx->extradata && (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER)) {
 436         int set_status = set_extradata(avctx, sample_buffer);
 437         if (set_status) {
 438             set_async_error(vtctx, set_status);
 439             return;
 440         }
 441     }
 442
 443     vtenc_q_push(vtctx, sample_buffer);
 444 }
 445
 446 static int get_length_code_size(
 447     AVCodecContext    *avctx,
 448     CMSampleBufferRef sample_buffer,
 449     size_t            *size)
 450 {
 451     CMVideoFormatDescriptionRef vid_fmt;
 452     int isize;
 453     int status;
 454
 455     vid_fmt = CMSampleBufferGetFormatDescription(sample_buffer);
 456     if (!vid_fmt) {
 457         av_log(avctx, AV_LOG_ERROR, "Error getting buffer format description.\n");
 458         return AVERROR_EXTERNAL;
 459     }
 460
 461     status = CMVideoFormatDescriptionGetH264ParameterSetAtIndex(vid_fmt,
 462                                                                 0,
 463                                                                 NULL,
 464                                                                 NULL,
 465                                                                 NULL,
 466                                                                 &isize);
 467     if (status) {
 468         av_log(avctx, AV_LOG_ERROR, "Error getting length code size: %d\n", status);
 469         return AVERROR_EXTERNAL;
 470     }
 471
 472     *size = isize;
 473     return 0;
 474 }
 475
 476 /*
 477  * Returns true on success.
 478  *
 479  * If profile_level_val is NULL and this method returns true, don't specify the
 480  * profile/level to the encoder.
 481  */
 482 static bool get_vt_profile_level(AVCodecContext *avctx,
 483                                  CFStringRef    *profile_level_val)
 484 {
 485     VTEncContext *vtctx = avctx->priv_data;
 486     int64_t profile = vtctx->profile;
 487
 488     if (profile == H264_PROF_AUTO && vtctx->level) {
 489         //Need to pick a profile if level is not auto-selected.
 490         profile = vtctx->has_b_frames ? H264_PROF_MAIN : H264_PROF_BASELINE;
 491     }
 492
 493     *profile_level_val = NULL;
 494
 495     switch (profile) {
 496         case H264_PROF_AUTO:
 497             return true;
 498
 499         case H264_PROF_BASELINE:
 500             switch (vtctx->level) {
 501                 case  0: *profile_level_val = kVTProfileLevel_H264_Baseline_AutoLevel; break;
 502                 case 13: *profile_level_val = kVTProfileLevel_H264_Baseline_1_3;       break;
 503                 case 30: *profile_level_val = kVTProfileLevel_H264_Baseline_3_0;       break;
 504                 case 31: *profile_level_val = kVTProfileLevel_H264_Baseline_3_1;       break;
 505                 case 32: *profile_level_val = kVTProfileLevel_H264_Baseline_3_2;       break;
 506                 case 40: *profile_level_val = kVTProfileLevel_H264_Baseline_4_0;       break;
 507                 case 41: *profile_level_val = kVTProfileLevel_H264_Baseline_4_1;       break;
 508                 case 42: *profile_level_val = kVTProfileLevel_H264_Baseline_4_2;       break;
 509                 case 50: *profile_level_val = kVTProfileLevel_H264_Baseline_5_0;       break;
 510                 case 51: *profile_level_val = kVTProfileLevel_H264_Baseline_5_1;       break;
 511                 case 52: *profile_level_val = kVTProfileLevel_H264_Baseline_5_2;       break;
 512             }
 513             break;
 514
 515         case H264_PROF_MAIN:
 516             switch (vtctx->level) {
 517                 case  0: *profile_level_val = kVTProfileLevel_H264_Main_AutoLevel; break;
 518                 case 30: *profile_level_val = kVTProfileLevel_H264_Main_3_0;       break;
 519                 case 31: *profile_level_val = kVTProfileLevel_H264_Main_3_1;       break;
 520                 case 32: *profile_level_val = kVTProfileLevel_H264_Main_3_2;       break;
 521                 case 40: *profile_level_val = kVTProfileLevel_H264_Main_4_0;       break;
 522                 case 41: *profile_level_val = kVTProfileLevel_H264_Main_4_1;       break;
 523                 case 42: *profile_level_val = kVTProfileLevel_H264_Main_4_2;       break;
 524                 case 50: *profile_level_val = kVTProfileLevel_H264_Main_5_0;       break;
 525                 case 51: *profile_level_val = kVTProfileLevel_H264_Main_5_1;       break;
 526                 case 52: *profile_level_val = kVTProfileLevel_H264_Main_5_2;       break;
 527             }
 528             break;
 529
 530         case H264_PROF_HIGH:
 531             switch (vtctx->level) {
 532                 case  0: *profile_level_val = kVTProfileLevel_H264_High_AutoLevel; break;
 533                 case 30: *profile_level_val = kVTProfileLevel_H264_High_3_0;       break;
 534                 case 31: *profile_level_val = kVTProfileLevel_H264_High_3_1;       break;
 535                 case 32: *profile_level_val = kVTProfileLevel_H264_High_3_2;       break;
 536                 case 40: *profile_level_val = kVTProfileLevel_H264_High_4_0;       break;
 537                 case 41: *profile_level_val = kVTProfileLevel_H264_High_4_1;       break;
 538                 case 42: *profile_level_val = kVTProfileLevel_H264_High_4_2;       break;
 539                 case 50: *profile_level_val = kVTProfileLevel_H264_High_5_0;       break;
 540                 case 51: *profile_level_val = kVTProfileLevel_H264_High_5_1;       break;
 541                 case 52: *profile_level_val = kVTProfileLevel_H264_High_5_2;       break;
 542             }
 543             break;
 544     }
 545
 546     if (!*profile_level_val) {
 547         av_log(avctx, AV_LOG_ERROR, "Invalid Profile/Level.\n");
 548         return false;
 549     }
 550
 551     return true;
 552 }
 553
 554 static int get_cv_pixel_format(AVCodecContext* avctx,
 555                                enum AVPixelFormat fmt,
 556                                enum AVColorRange range,
 557                                int* av_pixel_format,
 558                                int* range_guessed)
 559 {
 560     if (range_guessed) *range_guessed = range != AVCOL_RANGE_MPEG &&
 561                                         range != AVCOL_RANGE_JPEG;
 562
 563     //MPEG range is used when no range is set
 564     if (fmt == AV_PIX_FMT_NV12) {
 565         *av_pixel_format = range == AVCOL_RANGE_JPEG ?
 566                                         kCVPixelFormatType_420YpCbCr8BiPlanarFullRange :
 567                                         kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange;
 568     } else if (fmt == AV_PIX_FMT_YUV420P) {
 569         *av_pixel_format = range == AVCOL_RANGE_JPEG ?
 570                                         kCVPixelFormatType_420YpCbCr8PlanarFullRange :
 571                                         kCVPixelFormatType_420YpCbCr8Planar;
 572     } else {
 573         return AVERROR(EINVAL);
 574     }
 575
 576     return 0;
 577 }
 578
 579 static void add_color_attr(AVCodecContext *avctx, CFMutableDictionaryRef dict) {
 580     VTEncContext *vtctx = avctx->priv_data;
 581
 582     if (vtctx->color_primaries) {
 583         CFDictionarySetValue(dict,
 584                              kCVImageBufferColorPrimariesKey,
 585                              vtctx->color_primaries);
 586     }
 587
 588     if (vtctx->transfer_function) {
 589         CFDictionarySetValue(dict,
 590                              kCVImageBufferTransferFunctionKey,
 591                              vtctx->transfer_function);
 592     }
 593
 594     if (vtctx->ycbcr_matrix) {
 595         CFDictionarySetValue(dict,
 596                              kCVImageBufferYCbCrMatrixKey,
 597                              vtctx->ycbcr_matrix);
 598     }
 599 }
 600
 601 static int create_cv_pixel_buffer_info(AVCodecContext* avctx,
 602                                        CFMutableDictionaryRef* dict)
 603 {
 604     CFNumberRef cv_color_format_num = NULL;
 605     CFNumberRef width_num = NULL;
 606     CFNumberRef height_num = NULL;
 607     CFMutableDictionaryRef pixel_buffer_info = NULL;
 608     int cv_color_format;
 609     int status = get_cv_pixel_format(avctx,
 610                                      avctx->pix_fmt,
 611                                      avctx->color_range,
 612                                      &cv_color_format,
 613                                      NULL);
 614     if (status) return status;
 615
 616     pixel_buffer_info = CFDictionaryCreateMutable(
 617                             kCFAllocatorDefault,
 618                             20,
 619                             &kCFCopyStringDictionaryKeyCallBacks,
 620                             &kCFTypeDictionaryValueCallBacks);
 621
 622     if (!pixel_buffer_info) goto pbinfo_nomem;
 623
 624     cv_color_format_num = CFNumberCreate(kCFAllocatorDefault,
 625                                          kCFNumberSInt32Type,
 626                                          &cv_color_format);
 627     if (!cv_color_format_num) goto pbinfo_nomem;
 628
 629     CFDictionarySetValue(pixel_buffer_info,
 630                          kCVPixelBufferPixelFormatTypeKey,
 631                          cv_color_format_num);
 632     vt_release_num(&cv_color_format_num);
 633
 634     width_num = CFNumberCreate(kCFAllocatorDefault,
 635                                kCFNumberSInt32Type,
 636                                &avctx->width);
 637     if (!width_num) return AVERROR(ENOMEM);
 638
 639     CFDictionarySetValue(pixel_buffer_info,
 640                          kCVPixelBufferWidthKey,
 641                          width_num);
 642     vt_release_num(&width_num);
 643
 644     height_num = CFNumberCreate(kCFAllocatorDefault,
 645                                 kCFNumberSInt32Type,
 646                                 &avctx->height);
 647     if (!height_num) goto pbinfo_nomem;
 648
 649     CFDictionarySetValue(pixel_buffer_info,
 650                          kCVPixelBufferHeightKey,
 651                          height_num);
 652     vt_release_num(&height_num);
 653
 654     add_color_attr(avctx, pixel_buffer_info);
 655
 656     *dict = pixel_buffer_info;
 657     return 0;
 658
 659 pbinfo_nomem:
 660     vt_release_num(&cv_color_format_num);
 661     vt_release_num(&width_num);
 662     vt_release_num(&height_num);
 663     if (pixel_buffer_info) CFRelease(pixel_buffer_info);
 664
 665     return AVERROR(ENOMEM);
 666 }
 667
 668 static int get_cv_color_primaries(AVCodecContext *avctx,
 669                                   CFStringRef *primaries)
 670 {
 671     enum AVColorPrimaries pri = avctx->color_primaries;
 672     switch (pri) {
 673         case AVCOL_PRI_UNSPECIFIED:
 674             *primaries = NULL;
 675             break;
 676
 677         case AVCOL_PRI_BT709:
 678             *primaries = kCVImageBufferColorPrimaries_ITU_R_709_2;
 679             break;
 680
 681         case AVCOL_PRI_BT2020:
 682             *primaries = kCVImageBufferColorPrimaries_ITU_R_2020;
 683             break;
 684
 685         default:
 686             av_log(avctx, AV_LOG_ERROR, "Color primaries %s is not supported.\n", av_color_primaries_name(pri));
 687             *primaries = NULL;
 688             return -1;
 689     }
 690
 691     return 0;
 692 }
 693
 694 static int get_cv_transfer_function(AVCodecContext *avctx,
 695                                     CFStringRef *transfer_fnc,
 696                                     CFNumberRef *gamma_level)
 697 {
 698     enum AVColorTransferCharacteristic trc = avctx->color_trc;
 699     Float32 gamma;
 700     *gamma_level = NULL;
 701
 702     switch (trc) {
 703         case AVCOL_TRC_UNSPECIFIED:
 704             *transfer_fnc = NULL;
 705             break;
 706
 707         case AVCOL_TRC_BT709:
 708             *transfer_fnc = kCVImageBufferTransferFunction_ITU_R_709_2;
 709             break;
 710
 711         case AVCOL_TRC_SMPTE240M:
 712             *transfer_fnc = kCVImageBufferTransferFunction_SMPTE_240M_1995;
 713             break;
 714
 715         case AVCOL_TRC_GAMMA22:
 716             gamma = 2.2;
 717             *transfer_fnc = kCVImageBufferTransferFunction_UseGamma;
 718             *gamma_level = CFNumberCreate(NULL, kCFNumberFloat32Type, &gamma);
 719             break;
 720
 721         case AVCOL_TRC_GAMMA28:
 722             gamma = 2.8;
 723             *transfer_fnc = kCVImageBufferTransferFunction_UseGamma;
 724             *gamma_level = CFNumberCreate(NULL, kCFNumberFloat32Type, &gamma);
 725             break;
 726
 727         case AVCOL_TRC_BT2020_10:
 728         case AVCOL_TRC_BT2020_12:
 729             *transfer_fnc = kCVImageBufferTransferFunction_ITU_R_2020;
 730             break;
 731
 732         default:
 733             av_log(avctx, AV_LOG_ERROR, "Transfer function %s is not supported.\n", av_color_transfer_name(trc));
 734             return -1;
 735     }
 736
 737     return 0;
 738 }
 739
 740 static int get_cv_ycbcr_matrix(AVCodecContext *avctx, CFStringRef *matrix) {
 741     switch(avctx->colorspace) {
 742         case AVCOL_SPC_BT709:
 743             *matrix = kCVImageBufferYCbCrMatrix_ITU_R_709_2;
 744             break;
 745
 746         case AVCOL_SPC_UNSPECIFIED:
 747             *matrix = NULL;
 748             break;
 749
 750         case AVCOL_SPC_BT470BG:
 751         case AVCOL_SPC_SMPTE170M:
 752             *matrix = kCVImageBufferYCbCrMatrix_ITU_R_601_4;
 753             break;
 754
 755         case AVCOL_SPC_SMPTE240M:
 756             *matrix = kCVImageBufferYCbCrMatrix_SMPTE_240M_1995;
 757             break;
 758
 759         case AVCOL_SPC_BT2020_NCL:
 760             *matrix = kCVImageBufferYCbCrMatrix_ITU_R_2020;
 761             break;
 762
 763         default:
 764             av_log(avctx, AV_LOG_ERROR, "Color space %s is not supported.\n", av_color_space_name(avctx->colorspace));
 765             return -1;
 766     }
 767
 768     return 0;
 769 }
 770
 771 static int vtenc_create_encoder(AVCodecContext   *avctx,
 772                                 CMVideoCodecType codec_type,
 773                                 CFStringRef      profile_level,
 774                                 CFNumberRef      gamma_level,
 775                                 CFDictionaryRef  enc_info,
 776                                 CFDictionaryRef  pixel_buffer_info,
 777                                 VTCompressionSessionRef *session)
 778 {
 779     VTEncContext *vtctx = avctx->priv_data;
 780     SInt32       bit_rate = avctx->bit_rate;
 781     CFNumberRef  bit_rate_num;
 782
 783     int status = VTCompressionSessionCreate(kCFAllocatorDefault,
 784                                             avctx->width,
 785                                             avctx->height,
 786                                             codec_type,
 787                                             enc_info,
 788                                             pixel_buffer_info,
 789                                             kCFAllocatorDefault,
 790                                             vtenc_output_callback,
 791                                             avctx,
 792                                             session);
 793
 794     if (status || !vtctx->session) {
 795         av_log(avctx, AV_LOG_ERROR, "Error: cannot create compression session: %d\n", status);
 796
 797 #if !TARGET_OS_IPHONE
 798         if (!vtctx->allow_sw) {
 799             av_log(avctx, AV_LOG_ERROR, "Try -allow_sw 1. The hardware encoder may be busy, or not supported.\n");
 800         }
 801 #endif
 802
 803         return AVERROR_EXTERNAL;
 804     }
 805
 806     bit_rate_num = CFNumberCreate(kCFAllocatorDefault,
 807                                   kCFNumberSInt32Type,
 808                                   &bit_rate);
 809     if (!bit_rate_num) return AVERROR(ENOMEM);
 810
 811     status = VTSessionSetProperty(vtctx->session,
 812                                   kVTCompressionPropertyKey_AverageBitRate,
 813                                   bit_rate_num);
 814     CFRelease(bit_rate_num);
 815
 816     if (status) {
 817         av_log(avctx, AV_LOG_ERROR, "Error setting bitrate property: %d\n", status);
 818         return AVERROR_EXTERNAL;
 819     }
 820
 821     if (profile_level) {
 822         status = VTSessionSetProperty(vtctx->session,
 823                                       kVTCompressionPropertyKey_ProfileLevel,
 824                                       profile_level);
 825         if (status) {
 826             av_log(avctx, AV_LOG_ERROR, "Error setting profile/level property: %d\n", status);
 827             return AVERROR_EXTERNAL;
 828         }
 829     }
 830
 831     if (avctx->gop_size > 0) {
 832         CFNumberRef interval = CFNumberCreate(kCFAllocatorDefault,
 833                                               kCFNumberIntType,
 834                                               &avctx->gop_size);
 835         if (!interval) {
 836             return AVERROR(ENOMEM);
 837         }
 838
 839         status = VTSessionSetProperty(vtctx->session,
 840                                       kVTCompressionPropertyKey_MaxKeyFrameInterval,
 841                                       interval);
 842         CFRelease(interval);
 843
 844         if (status) {
 845             av_log(avctx, AV_LOG_ERROR, "Error setting 'max key-frame interval' property: %d\n", status);
 846             return AVERROR_EXTERNAL;
 847         }
 848     }
 849
 850     if (vtctx->frames_before) {
 851         status = VTSessionSetProperty(vtctx->session,
 852                                       kVTCompressionPropertyKey_MoreFramesBeforeStart,
 853                                       kCFBooleanTrue);
 854
 855         if (status == kVTPropertyNotSupportedErr) {
 856             av_log(avctx, AV_LOG_WARNING, "frames_before property is not supported on this device. Ignoring.\n");
 857         } else if (status) {
 858             av_log(avctx, AV_LOG_ERROR, "Error setting frames_before property: %d\n", status);
 859         }
 860     }
 861
 862     if (vtctx->frames_after) {
 863         status = VTSessionSetProperty(vtctx->session,
 864                                       kVTCompressionPropertyKey_MoreFramesAfterEnd,
 865                                       kCFBooleanTrue);
 866
 867         if (status == kVTPropertyNotSupportedErr) {
 868             av_log(avctx, AV_LOG_WARNING, "frames_after property is not supported on this device. Ignoring.\n");
 869         } else if (status) {
 870             av_log(avctx, AV_LOG_ERROR, "Error setting frames_after property: %d\n", status);
 871         }
 872     }
 873
 874     if (avctx->sample_aspect_ratio.num != 0) {
 875         CFNumberRef num;
 876         CFNumberRef den;
 877         CFMutableDictionaryRef par;
 878         AVRational *avpar = &avctx->sample_aspect_ratio;
 879
 880         av_reduce(&avpar->num, &avpar->den,
 881                    avpar->num,  avpar->den,
 882                   0xFFFFFFFF);
 883
 884         num = CFNumberCreate(kCFAllocatorDefault,
 885                              kCFNumberIntType,
 886                              &avpar->num);
 887
 888         den = CFNumberCreate(kCFAllocatorDefault,
 889                              kCFNumberIntType,
 890                              &avpar->den);
 891
 892
 893
 894         par = CFDictionaryCreateMutable(kCFAllocatorDefault,
 895                                         2,
 896                                         &kCFCopyStringDictionaryKeyCallBacks,
 897                                         &kCFTypeDictionaryValueCallBacks);
 898
 899         if (!par || !num || !den) {
 900             if (par) CFRelease(par);
 901             if (num) CFRelease(num);
 902             if (den) CFRelease(den);
 903
 904             return AVERROR(ENOMEM);
 905         }
 906
 907         CFDictionarySetValue(
 908             par,
 909             kCMFormatDescriptionKey_PixelAspectRatioHorizontalSpacing,
 910             num);
 911
 912         CFDictionarySetValue(
 913             par,
 914             kCMFormatDescriptionKey_PixelAspectRatioVerticalSpacing,
 915             den);
 916
 917         status = VTSessionSetProperty(vtctx->session,
 918                                       kVTCompressionPropertyKey_PixelAspectRatio,
 919                                       par);
 920
 921         CFRelease(par);
 922         CFRelease(num);
 923         CFRelease(den);
 924
 925         if (status) {
 926             av_log(avctx,
 927                    AV_LOG_ERROR,
 928                    "Error setting pixel aspect ratio to %d:%d: %d.\n",
 929                    avctx->sample_aspect_ratio.num,
 930                    avctx->sample_aspect_ratio.den,
 931                    status);
 932
 933             return AVERROR_EXTERNAL;
 934         }
 935     }
 936
 937
 938     if (vtctx->transfer_function) {
 939         status = VTSessionSetProperty(vtctx->session,
 940                                       kVTCompressionPropertyKey_TransferFunction,
 941                                       vtctx->transfer_function);
 942
 943         if (status) {
 944             av_log(avctx, AV_LOG_WARNING, "Could not set transfer function: %d\n", status);
 945         }
 946     }
 947
 948
 949     if (vtctx->ycbcr_matrix) {
 950         status = VTSessionSetProperty(vtctx->session,
 951                                       kVTCompressionPropertyKey_YCbCrMatrix,
 952                                       vtctx->ycbcr_matrix);
 953
 954         if (status) {
 955             av_log(avctx, AV_LOG_WARNING, "Could not set ycbcr matrix: %d\n", status);
 956         }
 957     }
 958
 959
 960     if (vtctx->color_primaries) {
 961         status = VTSessionSetProperty(vtctx->session,
 962                                       kVTCompressionPropertyKey_ColorPrimaries,
 963                                       vtctx->color_primaries);
 964
 965         if (status) {
 966             av_log(avctx, AV_LOG_WARNING, "Could not set color primaries: %d\n", status);
 967         }
 968     }
 969
 970     if (gamma_level) {
 971         status = VTSessionSetProperty(vtctx->session,
 972                                       kCVImageBufferGammaLevelKey,
 973                                       gamma_level);
 974
 975         if (status) {
 976             av_log(avctx, AV_LOG_WARNING, "Could not set gamma level: %d\n", status);
 977         }
 978     }
 979
 980     if (!vtctx->has_b_frames) {
 981         status = VTSessionSetProperty(vtctx->session,
 982                                       kVTCompressionPropertyKey_AllowFrameReordering,
 983                                       kCFBooleanFalse);
 984
 985         if (status) {
 986             av_log(avctx, AV_LOG_ERROR, "Error setting 'allow frame reordering' property: %d\n", status);
 987             return AVERROR_EXTERNAL;
 988         }
 989     }
 990
 991     if (vtctx->entropy != VT_ENTROPY_NOT_SET) {
 992         CFStringRef entropy = vtctx->entropy == VT_CABAC ?
 993                                 kVTH264EntropyMode_CABAC:
 994                                 kVTH264EntropyMode_CAVLC;
 995
 996         status = VTSessionSetProperty(vtctx->session,
 997                                       kVTCompressionPropertyKey_H264EntropyMode,
 998                                       entropy);
 999
1000         if (status) {
1001             av_log(avctx, AV_LOG_ERROR, "Error setting entropy property: %d\n", status);
1002             return AVERROR_EXTERNAL;
1003         }
1004     }
1005
1006     if (vtctx->realtime) {
1007         status = VTSessionSetProperty(vtctx->session,
1008                                       kVTCompressionPropertyKey_RealTime,
1009                                       kCFBooleanTrue);
1010
1011         if (status) {
1012             av_log(avctx, AV_LOG_ERROR, "Error setting realtime property: %d\n", status);
1013         }
1014     }
1015
1016     status = VTCompressionSessionPrepareToEncodeFrames(vtctx->session);
1017     if (status) {
1018         av_log(avctx, AV_LOG_ERROR, "Error: cannot prepare encoder: %d\n", status);
1019         return AVERROR_EXTERNAL;
1020     }
1021
1022     return 0;
1023 }
1024
1025 static av_cold int vtenc_init(AVCodecContext *avctx)
1026 {
1027     CFMutableDictionaryRef enc_info;
1028     CFMutableDictionaryRef pixel_buffer_info;
1029     CMVideoCodecType       codec_type;
1030     VTEncContext           *vtctx = avctx->priv_data;
1031     CFStringRef            profile_level;
1032     CFBooleanRef           has_b_frames_cfbool;
1033     CFNumberRef            gamma_level = NULL;
1034     int                    status;
1035
1036     codec_type = get_cm_codec_type(avctx->codec_id);
1037     if (!codec_type) {
1038         av_log(avctx, AV_LOG_ERROR, "Error: no mapping for AVCodecID %d\n", avctx->codec_id);
1039         return AVERROR(EINVAL);
1040     }
1041
1042     vtctx->has_b_frames = avctx->max_b_frames > 0;
1043     if(vtctx->has_b_frames && vtctx->profile == H264_PROF_BASELINE){
1044         av_log(avctx, AV_LOG_WARNING, "Cannot use B-frames with baseline profile. Output will not contain B-frames.\n");
1045         vtctx->has_b_frames = false;
1046     }
1047
1048     if (vtctx->entropy == VT_CABAC && vtctx->profile == H264_PROF_BASELINE) {
1049         av_log(avctx, AV_LOG_WARNING, "CABAC entropy requires 'main' or 'high' profile, but baseline was requested. Encode will not use CABAC entropy.\n");
1050         vtctx->entropy = VT_ENTROPY_NOT_SET;
1051     }
1052
1053     if (!get_vt_profile_level(avctx, &profile_level)) return AVERROR(EINVAL);
1054
1055     vtctx->session = NULL;
1056
1057     enc_info = CFDictionaryCreateMutable(
1058         kCFAllocatorDefault,
1059         20,
1060         &kCFCopyStringDictionaryKeyCallBacks,
1061         &kCFTypeDictionaryValueCallBacks
1062     );
1063
1064     if (!enc_info) return AVERROR(ENOMEM);
1065
1066 #if !TARGET_OS_IPHONE
1067     if (!vtctx->allow_sw) {
1068         CFDictionarySetValue(enc_info, kVTVideoEncoderSpecification_RequireHardwareAcceleratedVideoEncoder, kCFBooleanTrue);
1069     } else {
1070         CFDictionarySetValue(enc_info, kVTVideoEncoderSpecification_EnableHardwareAcceleratedVideoEncoder,  kCFBooleanTrue);
1071     }
1072 #endif
1073
1074     if (avctx->pix_fmt != AV_PIX_FMT_VIDEOTOOLBOX) {
1075         status = create_cv_pixel_buffer_info(avctx, &pixel_buffer_info);
1076         if (status)
1077             goto init_cleanup;
1078     } else {
1079         pixel_buffer_info = NULL;
1080     }
1081
1082     pthread_mutex_init(&vtctx->lock, NULL);
1083     pthread_cond_init(&vtctx->cv_sample_sent, NULL);
1084     vtctx->dts_delta = vtctx->has_b_frames ? -1 : 0;
1085
1086     get_cv_transfer_function(avctx, &vtctx->transfer_function, &gamma_level);
1087     get_cv_ycbcr_matrix(avctx, &vtctx->ycbcr_matrix);
1088     get_cv_color_primaries(avctx, &vtctx->color_primaries);
1089
1090
1091     if (avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
1092         status = vtenc_populate_extradata(avctx,
1093                                           codec_type,
1094                                           profile_level,
1095                                           gamma_level,
1096                                           enc_info,
1097                                           pixel_buffer_info);
1098         if (status)
1099             goto init_cleanup;
1100     }
1101
1102     status = vtenc_create_encoder(avctx,
1103                                   codec_type,
1104                                   profile_level,
1105                                   gamma_level,
1106                                   enc_info,
1107                                   pixel_buffer_info,
1108                                   &vtctx->session);
1109
1110     if (status < 0)
1111         goto init_cleanup;
1112
1113     status = VTSessionCopyProperty(vtctx->session,
1114                                    kVTCompressionPropertyKey_AllowFrameReordering,
1115                                    kCFAllocatorDefault,
1116                                    &has_b_frames_cfbool);
1117
1118     if (!status) {
1119         //Some devices don't output B-frames for main profile, even if requested.
1120         vtctx->has_b_frames = CFBooleanGetValue(has_b_frames_cfbool);
1121         CFRelease(has_b_frames_cfbool);
1122     }
1123     avctx->has_b_frames = vtctx->has_b_frames;
1124
1125 init_cleanup:
1126     if (gamma_level)
1127         CFRelease(gamma_level);
1128
1129     if (pixel_buffer_info)
1130         CFRelease(pixel_buffer_info);
1131
1132     CFRelease(enc_info);
1133
1134     return status;
1135 }
1136
1137 static void vtenc_get_frame_info(CMSampleBufferRef buffer, bool *is_key_frame)
1138 {
1139     CFArrayRef      attachments;
1140     CFDictionaryRef attachment;
1141     CFBooleanRef    not_sync;
1142     CFIndex         len;
1143
1144     attachments = CMSampleBufferGetSampleAttachmentsArray(buffer, false);
1145     len = !attachments ? 0 : CFArrayGetCount(attachments);
1146
1147     if (!len) {
1148         *is_key_frame = true;
1149         return;
1150     }
1151
1152     attachment = CFArrayGetValueAtIndex(attachments, 0);
1153
1154     if (CFDictionaryGetValueIfPresent(attachment,
1155                                       kCMSampleAttachmentKey_NotSync,
1156                                       (const void **)&not_sync))
1157     {
1158         *is_key_frame = !CFBooleanGetValue(not_sync);
1159     } else {
1160         *is_key_frame = true;
1161     }
1162 }
1163
1164 /**
1165  * Copies NAL units and replaces length codes with
1166  * H.264 Annex B start codes. On failure, the contents of
1167  * dst_data may have been modified.
1168  *
1169  * @param length_code_size Byte length of each length code
1170  * @param src_data NAL units prefixed with length codes.
1171  * @param src_size Length of buffer, excluding any padding.
1172  * @param dst_data Must be zeroed before calling this function.
1173  *                 Contains the copied NAL units prefixed with
1174  *                 start codes when the function returns
1175  *                 successfully.
1176  * @param dst_size Length of dst_data
1177  * @return 0 on success
1178  *         AVERROR_INVALIDDATA if length_code_size is invalid
1179  *         AVERROR_BUFFER_TOO_SMALL if dst_data is too small
1180  *         or if a length_code in src_data specifies data beyond
1181  *         the end of its buffer.
1182  */
1183 static int copy_replace_length_codes(
1184     AVCodecContext *avctx,
1185     size_t        length_code_size,
1186     CMSampleBufferRef sample_buffer,
1187     uint8_t       *dst_data,
1188     size_t        dst_size)
1189 {
1190     size_t src_size = CMSampleBufferGetTotalSampleSize(sample_buffer);
1191     size_t remaining_src_size = src_size;
1192     size_t remaining_dst_size = dst_size;
1193     size_t src_offset = 0;
1194     int status;
1195     uint8_t size_buf[4];
1196     CMBlockBufferRef block = CMSampleBufferGetDataBuffer(sample_buffer);
1197
1198     if (length_code_size > 4) {
1199         return AVERROR_INVALIDDATA;
1200     }
1201
1202     while (remaining_src_size > 0) {
1203         size_t curr_src_len;
1204         size_t curr_dst_len;
1205         size_t box_len = 0;
1206         size_t i;
1207
1208         uint8_t       *dst_box;
1209
1210         status = CMBlockBufferCopyDataBytes(block,
1211                                             src_offset,
1212                                             length_code_size,
1213                                             size_buf);
1214         if (status) {
1215             av_log(avctx, AV_LOG_ERROR, "Cannot copy length: %d\n", status);
1216             return AVERROR_EXTERNAL;
1217         }
1218
1219         for (i = 0; i < length_code_size; i++) {
1220             box_len <<= 8;
1221             box_len |= size_buf[i];
1222         }
1223
1224         curr_src_len = box_len + length_code_size;
1225         curr_dst_len = box_len + sizeof(start_code);
1226
1227         if (remaining_src_size < curr_src_len) {
1228             return AVERROR_BUFFER_TOO_SMALL;
1229         }
1230
1231         if (remaining_dst_size < curr_dst_len) {
1232             return AVERROR_BUFFER_TOO_SMALL;
1233         }
1234
1235         dst_box = dst_data + sizeof(start_code);
1236
1237         memcpy(dst_data, start_code, sizeof(start_code));
1238         status = CMBlockBufferCopyDataBytes(block,
1239                                             src_offset + length_code_size,
1240                                             box_len,
1241                                             dst_box);
1242
1243         if (status) {
1244             av_log(avctx, AV_LOG_ERROR, "Cannot copy data: %d\n", status);
1245             return AVERROR_EXTERNAL;
1246         }
1247
1248         src_offset += curr_src_len;
1249         dst_data += curr_dst_len;
1250
1251         remaining_src_size -= curr_src_len;
1252         remaining_dst_size -= curr_dst_len;
1253     }
1254
1255     return 0;
1256 }
1257
1258 static int vtenc_cm_to_avpacket(
1259     AVCodecContext    *avctx,
1260     CMSampleBufferRef sample_buffer,
1261     AVPacket          *pkt)
1262 {
1263     VTEncContext *vtctx = avctx->priv_data;
1264
1265     int     status;
1266     bool    is_key_frame;
1267     bool    add_header;
1268     size_t  length_code_size;
1269     size_t  header_size = 0;
1270     size_t  in_buf_size;
1271     size_t  out_buf_size;
1272     int64_t dts_delta;
1273     int64_t time_base_num;
1274     int nalu_count;
1275     CMTime  pts;
1276     CMTime  dts;
1277     CMVideoFormatDescriptionRef vid_fmt;
1278
1279
1280     vtenc_get_frame_info(sample_buffer, &is_key_frame);
1281     status = get_length_code_size(avctx, sample_buffer, &length_code_size);
1282     if (status) return status;
1283
1284     add_header = is_key_frame && !(avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER);
1285
1286     if (add_header) {
1287         vid_fmt = CMSampleBufferGetFormatDescription(sample_buffer);
1288         if (!vid_fmt) {
1289             av_log(avctx, AV_LOG_ERROR, "Cannot get format description.\n");
1290             return AVERROR_EXTERNAL;
1291         }
1292
1293         int status = get_params_size(avctx, vid_fmt, &header_size);
1294         if (status) return status;
1295     }
1296
1297     status = count_nalus(length_code_size, sample_buffer, &nalu_count);
1298     if(status)
1299         return status;
1300
1301     in_buf_size = CMSampleBufferGetTotalSampleSize(sample_buffer);
1302     out_buf_size = header_size +
1303                    in_buf_size +
1304                    nalu_count * ((int)sizeof(start_code) - (int)length_code_size);
1305
1306     status = ff_alloc_packet2(avctx, pkt, out_buf_size, out_buf_size);
1307     if (status < 0)
1308         return status;
1309
1310     if (add_header) {
1311         status = copy_param_sets(avctx, vid_fmt, pkt->data, out_buf_size);
1312         if(status) return status;
1313     }
1314
1315     status = copy_replace_length_codes(
1316         avctx,
1317         length_code_size,
1318         sample_buffer,
1319         pkt->data + header_size,
1320         pkt->size - header_size
1321     );
1322
1323     if (status) {
1324         av_log(avctx, AV_LOG_ERROR, "Error copying packet data: %d", status);
1325         return status;
1326     }
1327
1328     if (is_key_frame) {
1329         pkt->flags |= AV_PKT_FLAG_KEY;
1330     }
1331
1332     pts = CMSampleBufferGetPresentationTimeStamp(sample_buffer);
1333     dts = CMSampleBufferGetDecodeTimeStamp      (sample_buffer);
1334
1335     if (CMTIME_IS_INVALID(dts)) {
1336         if (!vtctx->has_b_frames) {
1337             dts = pts;
1338         } else {
1339             av_log(avctx, AV_LOG_ERROR, "DTS is invalid.\n");
1340             return AVERROR_EXTERNAL;
1341         }
1342     }
1343
1344     dts_delta = vtctx->dts_delta >= 0 ? vtctx->dts_delta : 0;
1345     time_base_num = avctx->time_base.num;
1346     pkt->pts = pts.value / time_base_num;
1347     pkt->dts = dts.value / time_base_num - dts_delta;
1348     pkt->size = out_buf_size;
1349
1350     return 0;
1351 }
1352
1353 /*
1354  * contiguous_buf_size is 0 if not contiguous, and the size of the buffer
1355  * containing all planes if so.
1356  */
1357 static int get_cv_pixel_info(
1358     AVCodecContext *avctx,
1359     const AVFrame  *frame,
1360     int            *color,
1361     int            *plane_count,
1362     size_t         *widths,
1363     size_t         *heights,
1364     size_t         *strides,
1365     size_t         *contiguous_buf_size)
1366 {
1367     VTEncContext *vtctx = avctx->priv_data;
1368     int av_format       = frame->format;
1369     int av_color_range  = av_frame_get_color_range(frame);
1370     int i;
1371     int range_guessed;
1372     int status;
1373
1374     status = get_cv_pixel_format(avctx, av_format, av_color_range, color, &range_guessed);
1375     if (status) {
1376         av_log(avctx,
1377             AV_LOG_ERROR,
1378             "Could not get pixel format for color format '%s' range '%s'.\n",
1379             av_get_pix_fmt_name(av_format),
1380             av_color_range > AVCOL_RANGE_UNSPECIFIED &&
1381             av_color_range < AVCOL_RANGE_NB ?
1382                av_color_range_name(av_color_range) :
1383                "Unknown");
1384
1385         return AVERROR(EINVAL);
1386     }
1387
1388     if (range_guessed) {
1389         if (!vtctx->warned_color_range) {
1390             vtctx->warned_color_range = true;
1391             av_log(avctx,
1392                    AV_LOG_WARNING,
1393                    "Color range not set for %s. Using MPEG range.\n",
1394                    av_get_pix_fmt_name(av_format));
1395         }
1396
1397         av_log(avctx, AV_LOG_WARNING, "");
1398     }
1399
1400     switch (av_format) {
1401     case AV_PIX_FMT_NV12:
1402         *plane_count = 2;
1403
1404         widths [0] = avctx->width;
1405         heights[0] = avctx->height;
1406         strides[0] = frame ? frame->linesize[0] : avctx->width;
1407
1408         widths [1] = (avctx->width  + 1) / 2;
1409         heights[1] = (avctx->height + 1) / 2;
1410         strides[1] = frame ? frame->linesize[1] : (avctx->width + 1) & -2;
1411         break;
1412
1413     case AV_PIX_FMT_YUV420P:
1414         *plane_count = 3;
1415
1416         widths [0] = avctx->width;
1417         heights[0] = avctx->height;
1418         strides[0] = frame ? frame->linesize[0] : avctx->width;
1419
1420         widths [1] = (avctx->width  + 1) / 2;
1421         heights[1] = (avctx->height + 1) / 2;
1422         strides[1] = frame ? frame->linesize[1] : (avctx->width + 1) / 2;
1423
1424         widths [2] = (avctx->width  + 1) / 2;
1425         heights[2] = (avctx->height + 1) / 2;
1426         strides[2] = frame ? frame->linesize[2] : (avctx->width + 1) / 2;
1427         break;
1428
1429     default:
1430         av_log(
1431                avctx,
1432                AV_LOG_ERROR,
1433                "Could not get frame format info for color %d range %d.\n",
1434                av_format,
1435                av_color_range);
1436
1437         return AVERROR(EINVAL);
1438     }
1439
1440     *contiguous_buf_size = 0;
1441     for (i = 0; i < *plane_count; i++) {
1442         if (i < *plane_count - 1 &&
1443             frame->data[i] + strides[i] * heights[i] != frame->data[i + 1]) {
1444             *contiguous_buf_size = 0;
1445             break;
1446         }
1447
1448         *contiguous_buf_size += strides[i] * heights[i];
1449     }
1450
1451     return 0;
1452 }
1453
1454 #if !TARGET_OS_IPHONE
1455 //Not used on iOS - frame is always copied.
1456 static void free_avframe(
1457     void       *release_ctx,
1458     const void *data,
1459     size_t      size,
1460     size_t      plane_count,
1461     const void *plane_addresses[])
1462 {
1463     AVFrame *frame = release_ctx;
1464     av_frame_free(&frame);
1465 }
1466 #else
1467 //Not used on OSX - frame is never copied.
1468 static int copy_avframe_to_pixel_buffer(AVCodecContext   *avctx,
1469                                         const AVFrame    *frame,
1470                                         CVPixelBufferRef cv_img,
1471                                         const size_t     *plane_strides,
1472                                         const size_t     *plane_rows)
1473 {
1474     int i, j;
1475     size_t plane_count;
1476     int status;
1477     int rows;
1478     int src_stride;
1479     int dst_stride;
1480     uint8_t *src_addr;
1481     uint8_t *dst_addr;
1482     size_t copy_bytes;
1483
1484     status = CVPixelBufferLockBaseAddress(cv_img, 0);
1485     if (status) {
1486         av_log(
1487             avctx,
1488             AV_LOG_ERROR,
1489             "Error: Could not lock base address of CVPixelBuffer: %d.\n",
1490             status
1491         );
1492     }
1493
1494     if (CVPixelBufferIsPlanar(cv_img)) {
1495         plane_count = CVPixelBufferGetPlaneCount(cv_img);
1496         for (i = 0; frame->data[i]; i++) {
1497             if (i == plane_count) {
1498                 CVPixelBufferUnlockBaseAddress(cv_img, 0);
1499                 av_log(avctx,
1500                     AV_LOG_ERROR,
1501                     "Error: different number of planes in AVFrame and CVPixelBuffer.\n"
1502                 );
1503
1504                 return AVERROR_EXTERNAL;
1505             }
1506
1507             dst_addr = (uint8_t*)CVPixelBufferGetBaseAddressOfPlane(cv_img, i);
1508             src_addr = (uint8_t*)frame->data[i];
1509             dst_stride = CVPixelBufferGetBytesPerRowOfPlane(cv_img, i);
1510             src_stride = plane_strides[i];
1511             rows = plane_rows[i];
1512
1513             if (dst_stride == src_stride) {
1514                 memcpy(dst_addr, src_addr, src_stride * rows);
1515             } else {
1516                 copy_bytes = dst_stride < src_stride ? dst_stride : src_stride;
1517
1518                 for (j = 0; j < rows; j++) {
1519                     memcpy(dst_addr + j * dst_stride, src_addr + j * src_stride, copy_bytes);
1520                 }
1521             }
1522         }
1523     } else {
1524         if (frame->data[1]) {
1525             CVPixelBufferUnlockBaseAddress(cv_img, 0);
1526             av_log(avctx,
1527                 AV_LOG_ERROR,
1528                 "Error: different number of planes in AVFrame and non-planar CVPixelBuffer.\n"
1529             );
1530
1531             return AVERROR_EXTERNAL;
1532         }
1533
1534         dst_addr = (uint8_t*)CVPixelBufferGetBaseAddress(cv_img);
1535         src_addr = (uint8_t*)frame->data[0];
1536         dst_stride = CVPixelBufferGetBytesPerRow(cv_img);
1537         src_stride = plane_strides[0];
1538         rows = plane_rows[0];
1539
1540         if (dst_stride == src_stride) {
1541             memcpy(dst_addr, src_addr, src_stride * rows);
1542         } else {
1543             copy_bytes = dst_stride < src_stride ? dst_stride : src_stride;
1544
1545             for (j = 0; j < rows; j++) {
1546                 memcpy(dst_addr + j * dst_stride, src_addr + j * src_stride, copy_bytes);
1547             }
1548         }
1549     }
1550
1551     status = CVPixelBufferUnlockBaseAddress(cv_img, 0);
1552     if (status) {
1553         av_log(avctx, AV_LOG_ERROR, "Error: Could not unlock CVPixelBuffer base address: %d.\n", status);
1554         return AVERROR_EXTERNAL;
1555     }
1556
1557     return 0;
1558 }
1559 #endif //!TARGET_OS_IPHONE
1560
1561 static int create_cv_pixel_buffer(AVCodecContext   *avctx,
1562                                   const AVFrame    *frame,
1563                                   CVPixelBufferRef *cv_img)
1564 {
1565     int plane_count;
1566     int color;
1567     size_t widths [AV_NUM_DATA_POINTERS];
1568     size_t heights[AV_NUM_DATA_POINTERS];
1569     size_t strides[AV_NUM_DATA_POINTERS];
1570     int status;
1571     size_t contiguous_buf_size;
1572 #if TARGET_OS_IPHONE
1573     CVPixelBufferPoolRef pix_buf_pool;
1574     VTEncContext* vtctx = avctx->priv_data;
1575 #else
1576     CFMutableDictionaryRef pix_buf_attachments = CFDictionaryCreateMutable(
1577                                                    kCFAllocatorDefault,
1578                                                    10,
1579                                                    &kCFCopyStringDictionaryKeyCallBacks,
1580                                                    &kCFTypeDictionaryValueCallBacks);
1581
1582     if (!pix_buf_attachments) return AVERROR(ENOMEM);
1583 #endif
1584
1585     if (avctx->pix_fmt == AV_PIX_FMT_VIDEOTOOLBOX) {
1586         av_assert0(frame->format == AV_PIX_FMT_VIDEOTOOLBOX);
1587
1588         *cv_img = (CVPixelBufferRef)frame->data[3];
1589         av_assert0(*cv_img);
1590
1591         CFRetain(*cv_img);
1592         return 0;
1593     }
1594
1595     memset(widths,  0, sizeof(widths));
1596     memset(heights, 0, sizeof(heights));
1597     memset(strides, 0, sizeof(strides));
1598
1599     status = get_cv_pixel_info(
1600         avctx,
1601         frame,
1602         &color,
1603         &plane_count,
1604         widths,
1605         heights,
1606         strides,
1607         &contiguous_buf_size
1608     );
1609
1610     if (status) {
1611         av_log(
1612             avctx,
1613             AV_LOG_ERROR,
1614             "Error: Cannot convert format %d color_range %d: %d\n",
1615             frame->format,
1616             av_frame_get_color_range(frame),
1617             status
1618         );
1619
1620         return AVERROR_EXTERNAL;
1621     }
1622
1623 #if TARGET_OS_IPHONE
1624     pix_buf_pool = VTCompressionSessionGetPixelBufferPool(vtctx->session);
1625     if (!pix_buf_pool) {
1626         av_log(avctx, AV_LOG_ERROR, "Could not get pixel buffer pool.\n");
1627         return AVERROR_EXTERNAL;
1628     }
1629
1630     status = CVPixelBufferPoolCreatePixelBuffer(NULL,
1631                                                 pix_buf_pool,
1632                                                 cv_img);
1633
1634
1635     if (status) {
1636         av_log(avctx, AV_LOG_ERROR, "Could not create pixel buffer from pool: %d.\n", status);
1637         return AVERROR_EXTERNAL;
1638     }
1639
1640     status = copy_avframe_to_pixel_buffer(avctx, frame, *cv_img, strides, heights);
1641     if (status) {
1642         CFRelease(*cv_img);
1643         *cv_img = NULL;
1644         return status;
1645     }
1646 #else
1647     AVFrame *enc_frame = av_frame_alloc();
1648     if (!enc_frame) return AVERROR(ENOMEM);
1649
1650     status = av_frame_ref(enc_frame, frame);
1651     if (status) {
1652         av_frame_free(&enc_frame);
1653         return status;
1654     }
1655
1656     status = CVPixelBufferCreateWithPlanarBytes(
1657         kCFAllocatorDefault,
1658         enc_frame->width,
1659         enc_frame->height,
1660         color,
1661         NULL,
1662         contiguous_buf_size,
1663         plane_count,
1664         (void **)enc_frame->data,
1665         widths,
1666         heights,
1667         strides,
1668         free_avframe,
1669         enc_frame,
1670         NULL,
1671         cv_img
1672     );
1673
1674     add_color_attr(avctx, pix_buf_attachments);
1675     CVBufferSetAttachments(*cv_img, pix_buf_attachments, kCVAttachmentMode_ShouldPropagate);
1676     CFRelease(pix_buf_attachments);
1677
1678     if (status) {
1679         av_log(avctx, AV_LOG_ERROR, "Error: Could not create CVPixelBuffer: %d\n", status);
1680         return AVERROR_EXTERNAL;
1681     }
1682 #endif
1683
1684     return 0;
1685 }
1686
1687 static int create_encoder_dict_h264(const AVFrame *frame,
1688                                     CFDictionaryRef* dict_out)
1689 {
1690     CFDictionaryRef dict = NULL;
1691     if (frame->pict_type == AV_PICTURE_TYPE_I) {
1692         const void *keys[] = { kVTEncodeFrameOptionKey_ForceKeyFrame };
1693         const void *vals[] = { kCFBooleanTrue };
1694
1695         dict = CFDictionaryCreate(NULL, keys, vals, 1, NULL, NULL);
1696         if(!dict) return AVERROR(ENOMEM);
1697     }
1698
1699     *dict_out = dict;
1700     return 0;
1701 }
1702
1703 static int vtenc_send_frame(AVCodecContext *avctx,
1704                             VTEncContext   *vtctx,
1705                             const AVFrame  *frame)
1706 {
1707     CMTime time;
1708     CFDictionaryRef frame_dict;
1709     CVPixelBufferRef cv_img = NULL;
1710     int status = create_cv_pixel_buffer(avctx, frame, &cv_img);
1711
1712     if (status) return status;
1713
1714     status = create_encoder_dict_h264(frame, &frame_dict);
1715     if (status) {
1716         CFRelease(cv_img);
1717         return status;
1718     }
1719
1720     time = CMTimeMake(frame->pts * avctx->time_base.num, avctx->time_base.den);
1721     status = VTCompressionSessionEncodeFrame(
1722         vtctx->session,
1723         cv_img,
1724         time,
1725         kCMTimeInvalid,
1726         frame_dict,
1727         NULL,
1728         NULL
1729     );
1730
1731     if (frame_dict) CFRelease(frame_dict);
1732     CFRelease(cv_img);
1733
1734     if (status) {
1735         av_log(avctx, AV_LOG_ERROR, "Error: cannot encode frame: %d\n", status);
1736         return AVERROR_EXTERNAL;
1737     }
1738
1739     return 0;
1740 }
1741
1742 static av_cold int vtenc_frame(
1743     AVCodecContext *avctx,
1744     AVPacket       *pkt,
1745     const AVFrame  *frame,
1746     int            *got_packet)
1747 {
1748     VTEncContext *vtctx = avctx->priv_data;
1749     bool get_frame;
1750     int status;
1751     CMSampleBufferRef buf = NULL;
1752
1753     if (frame) {
1754         status = vtenc_send_frame(avctx, vtctx, frame);
1755
1756         if (status) {
1757             status = AVERROR_EXTERNAL;
1758             goto end_nopkt;
1759         }
1760
1761         if (vtctx->frame_ct_in == 0) {
1762             vtctx->first_pts = frame->pts;
1763         } else if(vtctx->frame_ct_in == 1 && vtctx->has_b_frames) {
1764             vtctx->dts_delta = frame->pts - vtctx->first_pts;
1765         }
1766
1767         vtctx->frame_ct_in++;
1768     } else if(!vtctx->flushing) {
1769         vtctx->flushing = true;
1770
1771         status = VTCompressionSessionCompleteFrames(vtctx->session,
1772                                                     kCMTimeIndefinite);
1773
1774         if (status) {
1775             av_log(avctx, AV_LOG_ERROR, "Error flushing frames: %d\n", status);
1776             status = AVERROR_EXTERNAL;
1777             goto end_nopkt;
1778         }
1779     }
1780
1781     *got_packet = 0;
1782     get_frame = vtctx->dts_delta >= 0 || !frame;
1783     if (!get_frame) {
1784         status = 0;
1785         goto end_nopkt;
1786     }
1787
1788     status = vtenc_q_pop(vtctx, !frame, &buf);
1789     if (status) goto end_nopkt;
1790     if (!buf)   goto end_nopkt;
1791
1792     status = vtenc_cm_to_avpacket(avctx, buf, pkt);
1793     CFRelease(buf);
1794     if (status) goto end_nopkt;
1795
1796     *got_packet = 1;
1797     return 0;
1798
1799 end_nopkt:
1800     av_packet_unref(pkt);
1801     return status;
1802 }
1803
1804 static int vtenc_populate_extradata(AVCodecContext   *avctx,
1805                                     CMVideoCodecType codec_type,
1806                                     CFStringRef      profile_level,
1807                                     CFNumberRef      gamma_level,
1808                                     CFDictionaryRef  enc_info,
1809                                     CFDictionaryRef  pixel_buffer_info)
1810 {
1811     VTEncContext *vtctx = avctx->priv_data;
1812     AVFrame *frame = av_frame_alloc();
1813     int y_size = avctx->width * avctx->height;
1814     int chroma_size = (avctx->width / 2) * (avctx->height / 2);
1815     CMSampleBufferRef buf = NULL;
1816     int status;
1817
1818     if (!frame)
1819         return AVERROR(ENOMEM);
1820
1821     frame->buf[0] = av_buffer_alloc(y_size + 2 * chroma_size);
1822
1823     if(!frame->buf[0]){
1824         status = AVERROR(ENOMEM);
1825         goto pe_cleanup;
1826     }
1827
1828     status = vtenc_create_encoder(avctx,
1829                                   codec_type,
1830                                   profile_level,
1831                                   gamma_level,
1832                                   enc_info,
1833                                   pixel_buffer_info,
1834                                   &vtctx->session);
1835     if (status)
1836         goto pe_cleanup;
1837
1838     frame->data[0] = frame->buf[0]->data;
1839     memset(frame->data[0],   0,      y_size);
1840
1841     frame->data[1] = frame->buf[0]->data + y_size;
1842     memset(frame->data[1], 128, chroma_size);
1843
1844
1845     if (avctx->pix_fmt == AV_PIX_FMT_YUV420P) {
1846         frame->data[2] = frame->buf[0]->data + y_size + chroma_size;
1847         memset(frame->data[2], 128, chroma_size);
1848     }
1849
1850     frame->linesize[0] = avctx->width;
1851
1852     if (avctx->pix_fmt == AV_PIX_FMT_YUV420P) {
1853         frame->linesize[1] =
1854         frame->linesize[2] = (avctx->width + 1) / 2;
1855     } else {
1856         frame->linesize[1] = (avctx->width + 1) / 2;
1857     }
1858
1859     frame->format          = avctx->pix_fmt;
1860     frame->width           = avctx->width;
1861     frame->height          = avctx->height;
1862     av_frame_set_colorspace(frame, avctx->colorspace);
1863     av_frame_set_color_range(frame, avctx->color_range);
1864     frame->color_trc       = avctx->color_trc;
1865     frame->color_primaries = avctx->color_primaries;
1866
1867     frame->pts = 0;
1868     status = vtenc_send_frame(avctx, vtctx, frame);
1869     if (status) {
1870         av_log(avctx, AV_LOG_ERROR, "Error sending frame: %d\n", status);
1871         goto pe_cleanup;
1872     }
1873
1874     //Populates extradata - output frames are flushed and param sets are available.
1875     status = VTCompressionSessionCompleteFrames(vtctx->session,
1876                                                 kCMTimeIndefinite);
1877
1878     if (status)
1879         goto pe_cleanup;
1880
1881     status = vtenc_q_pop(vtctx, 0, &buf);
1882     if (status) {
1883         av_log(avctx, AV_LOG_ERROR, "popping: %d\n", status);
1884         goto pe_cleanup;
1885     }
1886
1887     CFRelease(buf);
1888
1889
1890
1891 pe_cleanup:
1892     if(vtctx->session)
1893         CFRelease(vtctx->session);
1894
1895     vtctx->session = NULL;
1896     vtctx->frame_ct_out = 0;
1897
1898     av_frame_unref(frame);
1899     av_frame_free(&frame);
1900
1901     av_assert0(status != 0 || (avctx->extradata && avctx->extradata_size > 0));
1902
1903     return status;
1904 }
1905
1906 static av_cold int vtenc_close(AVCodecContext *avctx)
1907 {
1908     VTEncContext *vtctx = avctx->priv_data;
1909
1910     if(!vtctx->session) return 0;
1911
1912     pthread_cond_destroy(&vtctx->cv_sample_sent);
1913     pthread_mutex_destroy(&vtctx->lock);
1914     CFRelease(vtctx->session);
1915     vtctx->session = NULL;
1916
1917     if (vtctx->color_primaries) {
1918         CFRelease(vtctx->color_primaries);
1919         vtctx->color_primaries = NULL;
1920     }
1921
1922     if (vtctx->transfer_function) {
1923         CFRelease(vtctx->transfer_function);
1924         vtctx->transfer_function = NULL;
1925     }
1926
1927     if (vtctx->ycbcr_matrix) {
1928         CFRelease(vtctx->ycbcr_matrix);
1929         vtctx->ycbcr_matrix = NULL;
1930     }
1931
1932     return 0;
1933 }
1934
1935 static const enum AVPixelFormat pix_fmts[] = {
1936     AV_PIX_FMT_VIDEOTOOLBOX,
1937     AV_PIX_FMT_NV12,
1938     AV_PIX_FMT_YUV420P,
1939     AV_PIX_FMT_NONE
1940 };
1941
1942 #define OFFSET(x) offsetof(VTEncContext, x)
1943 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1944 static const AVOption options[] = {
1945     { "profile", "Profile", OFFSET(profile), AV_OPT_TYPE_INT, { .i64 = H264_PROF_AUTO }, H264_PROF_AUTO, H264_PROF_COUNT, VE, "profile" },
1946     { "baseline", "Baseline Profile", 0, AV_OPT_TYPE_CONST, { .i64 = H264_PROF_BASELINE }, INT_MIN, INT_MAX, VE, "profile" },
1947     { "main",     "Main Profile",     0, AV_OPT_TYPE_CONST, { .i64 = H264_PROF_MAIN     }, INT_MIN, INT_MAX, VE, "profile" },
1948     { "high",     "High Profile",     0, AV_OPT_TYPE_CONST, { .i64 = H264_PROF_HIGH     }, INT_MIN, INT_MAX, VE, "profile" },
1949
1950     { "level", "Level", OFFSET(level), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 52, VE, "level" },
1951     { "1.3", "Level 1.3, only available with Baseline Profile", 0, AV_OPT_TYPE_CONST, { .i64 = 13 }, INT_MIN, INT_MAX, VE, "level" },
1952     { "3.0", "Level 3.0", 0, AV_OPT_TYPE_CONST, { .i64 = 30 }, INT_MIN, INT_MAX, VE, "level" },
1953     { "3.1", "Level 3.1", 0, AV_OPT_TYPE_CONST, { .i64 = 31 }, INT_MIN, INT_MAX, VE, "level" },
1954     { "3.2", "Level 3.2", 0, AV_OPT_TYPE_CONST, { .i64 = 32 }, INT_MIN, INT_MAX, VE, "level" },
1955     { "4.0", "Level 4.0", 0, AV_OPT_TYPE_CONST, { .i64 = 40 }, INT_MIN, INT_MAX, VE, "level" },
1956     { "4.1", "Level 4.1", 0, AV_OPT_TYPE_CONST, { .i64 = 41 }, INT_MIN, INT_MAX, VE, "level" },
1957     { "4.2", "Level 4.2", 0, AV_OPT_TYPE_CONST, { .i64 = 42 }, INT_MIN, INT_MAX, VE, "level" },
1958     { "5.0", "Level 5.0", 0, AV_OPT_TYPE_CONST, { .i64 = 50 }, INT_MIN, INT_MAX, VE, "level" },
1959     { "5.1", "Level 5.1", 0, AV_OPT_TYPE_CONST, { .i64 = 51 }, INT_MIN, INT_MAX, VE, "level" },
1960     { "5.2", "Level 5.2", 0, AV_OPT_TYPE_CONST, { .i64 = 52 }, INT_MIN, INT_MAX, VE, "level" },
1961
1962     { "allow_sw", "Allow software encoding", OFFSET(allow_sw), AV_OPT_TYPE_BOOL,
1963         { .i64 = 0 }, 0, 1, VE },
1964
1965     { "coder", "Entropy coding", OFFSET(entropy), AV_OPT_TYPE_INT, { .i64 = VT_ENTROPY_NOT_SET }, VT_ENTROPY_NOT_SET, VT_CABAC, VE, "coder" },
1966     { "cavlc", "CAVLC entropy coding", 0, AV_OPT_TYPE_CONST, { .i64 = VT_CAVLC }, INT_MIN, INT_MAX, VE, "coder" },
1967     { "vlc",   "CAVLC entropy coding", 0, AV_OPT_TYPE_CONST, { .i64 = VT_CAVLC }, INT_MIN, INT_MAX, VE, "coder" },
1968     { "cabac", "CABAC entropy coding", 0, AV_OPT_TYPE_CONST, { .i64 = VT_CABAC }, INT_MIN, INT_MAX, VE, "coder" },
1969     { "ac",    "CABAC entropy coding", 0, AV_OPT_TYPE_CONST, { .i64 = VT_CABAC }, INT_MIN, INT_MAX, VE, "coder" },
1970
1971     { "realtime", "Hint that encoding should happen in real-time if not faster (e.g. capturing from camera).",
1972         OFFSET(realtime), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
1973
1974     { "frames_before", "Other frames will come before the frames in this session. This helps smooth concatenation issues.",
1975         OFFSET(frames_before), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
1976     { "frames_after", "Other frames will come after the frames in this session. This helps smooth concatenation issues.",
1977         OFFSET(frames_after), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
1978
1979     { NULL },
1980 };
1981
1982 static const AVClass h264_videotoolbox_class = {
1983     .class_name = "h264_videotoolbox",
1984     .item_name  = av_default_item_name,
1985     .option     = options,
1986     .version    = LIBAVUTIL_VERSION_INT,
1987 };
1988
1989 AVCodec ff_h264_videotoolbox_encoder = {
1990     .name             = "h264_videotoolbox",
1991     .long_name        = NULL_IF_CONFIG_SMALL("VideoToolbox H.264 Encoder"),
1992     .type             = AVMEDIA_TYPE_VIDEO,
1993     .id               = AV_CODEC_ID_H264,
1994     .priv_data_size   = sizeof(VTEncContext),
1995     .pix_fmts         = pix_fmts,
1996     .init             = vtenc_init,
1997     .encode2          = vtenc_frame,
1998     .close            = vtenc_close,
1999     .capabilities     = AV_CODEC_CAP_DELAY,
2000     .priv_class       = &h264_videotoolbox_class,
2001     .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE |
2002                         FF_CODEC_CAP_INIT_CLEANUP,
2003 };