FFmpeg: libavutil/hwcontext_videotoolbox.c Source File

FFmpeg

[フレーム]

libavutil

hwcontext_videotoolbox.c

Go to the documentation of this file.

1 /*

2 * This file is part of FFmpeg.

3 *

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

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

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

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

8 *

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

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

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

12 * Lesser General Public License for more details.

13 *

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

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

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

17 */

19 #include "config.h"

21 #include <stdint.h>

22 #include <string.h>

24 #include <VideoToolbox/VideoToolbox.h>

26 #include "buffer.h"

27 #include "buffer_internal.h"

28 #include "common.h"

29 #include "hwcontext.h"

30 #include "hwcontext_internal.h"

31 #include "hwcontext_videotoolbox.h"

32 #include "mem.h"

33 #include "pixfmt.h"

34 #include "pixdesc.h"

36 typedef struct VTFramesContext {

37 /**

38 * The public AVVTFramesContext. See hwcontext_videotoolbox.h for it.

39 */

40 AVVTFramesContext p;

41 CVPixelBufferPoolRef pool;

42 } VTFramesContext;

44 static const struct {

45 uint32_t cv_fmt;

46 bool full_range;

47 enum AVPixelFormat pix_fmt;

48 } cv_pix_fmts[] = {

49 { kCVPixelFormatType_420YpCbCr8Planar, false, AV_PIX_FMT_YUV420P },

50 { kCVPixelFormatType_420YpCbCr8PlanarFullRange, true, AV_PIX_FMT_YUV420P },

51 { kCVPixelFormatType_422YpCbCr8, false, AV_PIX_FMT_UYVY422 },

52 { kCVPixelFormatType_32BGRA, true, AV_PIX_FMT_BGRA },

53 #ifdef kCFCoreFoundationVersionNumber10_7

54 { kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange, false, AV_PIX_FMT_NV12 },

55 { kCVPixelFormatType_420YpCbCr8BiPlanarFullRange, true, AV_PIX_FMT_NV12 },

56 { kCVPixelFormatType_4444AYpCbCr16, false, AV_PIX_FMT_AYUV64 },

57 #endif

58 #if HAVE_KCVPIXELFORMATTYPE_420YPCBCR10BIPLANARVIDEORANGE

59 { kCVPixelFormatType_420YpCbCr10BiPlanarVideoRange, false, AV_PIX_FMT_P010 },

60 { kCVPixelFormatType_420YpCbCr10BiPlanarFullRange, true, AV_PIX_FMT_P010 },

61 #endif

62 #if HAVE_KCVPIXELFORMATTYPE_422YPCBCR8BIPLANARVIDEORANGE

63 { kCVPixelFormatType_422YpCbCr8BiPlanarVideoRange, false, AV_PIX_FMT_NV16 },

64 { kCVPixelFormatType_422YpCbCr8BiPlanarFullRange, true, AV_PIX_FMT_NV16 },

65 #endif

66 #if HAVE_KCVPIXELFORMATTYPE_422YPCBCR10BIPLANARVIDEORANGE

67 { kCVPixelFormatType_422YpCbCr10BiPlanarVideoRange, false, AV_PIX_FMT_P210 },

68 { kCVPixelFormatType_422YpCbCr10BiPlanarFullRange, true, AV_PIX_FMT_P210 },

69 #endif

70 #if HAVE_KCVPIXELFORMATTYPE_422YPCBCR16BIPLANARVIDEORANGE

71 { kCVPixelFormatType_422YpCbCr16BiPlanarVideoRange, false, AV_PIX_FMT_P216 },

72 #endif

73 #if HAVE_KCVPIXELFORMATTYPE_444YPCBCR8BIPLANARVIDEORANGE

74 { kCVPixelFormatType_444YpCbCr8BiPlanarVideoRange, false, AV_PIX_FMT_NV24 },

75 { kCVPixelFormatType_444YpCbCr8BiPlanarFullRange, true, AV_PIX_FMT_NV24 },

76 #endif

77 #if HAVE_KCVPIXELFORMATTYPE_444YPCBCR10BIPLANARVIDEORANGE

78 { kCVPixelFormatType_444YpCbCr10BiPlanarVideoRange, false, AV_PIX_FMT_P410 },

79 { kCVPixelFormatType_444YpCbCr10BiPlanarFullRange, true, AV_PIX_FMT_P410 },

80 #endif

81 #if HAVE_KCVPIXELFORMATTYPE_444YPCBCR16BIPLANARVIDEORANGE

82 { kCVPixelFormatType_444YpCbCr16BiPlanarVideoRange, false, AV_PIX_FMT_P416 },

83 #endif

84 };

86 static const enum AVPixelFormat supported_formats[] = {

87 #ifdef kCFCoreFoundationVersionNumber10_7

88 AV_PIX_FMT_NV12,

89 AV_PIX_FMT_AYUV64,

90 #endif

91 AV_PIX_FMT_YUV420P,

92 AV_PIX_FMT_UYVY422,

93 #if HAVE_KCVPIXELFORMATTYPE_420YPCBCR10BIPLANARVIDEORANGE

94 AV_PIX_FMT_P010,

95 #endif

96 #if HAVE_KCVPIXELFORMATTYPE_422YPCBCR8BIPLANARVIDEORANGE

97 AV_PIX_FMT_NV16,

98 #endif

99 #if HAVE_KCVPIXELFORMATTYPE_422YPCBCR10BIPLANARVIDEORANGE

100 AV_PIX_FMT_P210,

101 #endif

102 #if HAVE_KCVPIXELFORMATTYPE_422YPCBCR16BIPLANARVIDEORANGE

103 AV_PIX_FMT_P216,

104 #endif

105 #if HAVE_KCVPIXELFORMATTYPE_444YPCBCR8BIPLANARVIDEORANGE

106 AV_PIX_FMT_NV24,

107 #endif

108 #if HAVE_KCVPIXELFORMATTYPE_444YPCBCR10BIPLANARVIDEORANGE

109 AV_PIX_FMT_P410,

110 #endif

111 #if HAVE_KCVPIXELFORMATTYPE_444YPCBCR16BIPLANARVIDEORANGE

112 AV_PIX_FMT_P416,

113 #endif

114 AV_PIX_FMT_BGRA,

115 };

116

117 static int vt_frames_get_constraints(AVHWDeviceContext *ctx,

118 const void *hwconfig,

119 AVHWFramesConstraints *constraints)

120 {

121 int i;

122

123 constraints->valid_sw_formats = av_malloc_array(FF_ARRAY_ELEMS(supported_formats) + 1,

124 sizeof(*constraints->valid_sw_formats));

125 if (!constraints->valid_sw_formats)

126 return AVERROR(ENOMEM);

127

128 for (i = 0; i < FF_ARRAY_ELEMS(supported_formats); i++)

129 constraints->valid_sw_formats[i] = supported_formats[i];

130 constraints->valid_sw_formats[FF_ARRAY_ELEMS(supported_formats)] = AV_PIX_FMT_NONE;

131

132 constraints->valid_hw_formats = av_malloc_array(2, sizeof(*constraints->valid_hw_formats));

133 if (!constraints->valid_hw_formats)

134 return AVERROR(ENOMEM);

135

136 constraints->valid_hw_formats[0] = AV_PIX_FMT_VIDEOTOOLBOX;

137 constraints->valid_hw_formats[1] = AV_PIX_FMT_NONE;

138

139 return 0;

140 }

141

142 enum AVPixelFormat av_map_videotoolbox_format_to_pixfmt(uint32_t cv_fmt)

143 {

144 int i;

145 for (i = 0; i < FF_ARRAY_ELEMS(cv_pix_fmts); i++) {

146 if (cv_pix_fmts[i].cv_fmt == cv_fmt)

147 return cv_pix_fmts[i].pix_fmt;

148 }

149 return AV_PIX_FMT_NONE;

150 }

151

152 static uint32_t vt_format_from_pixfmt(enum AVPixelFormat pix_fmt,

153 enum AVColorRange range)

154 {

155 for (int i = 0; i < FF_ARRAY_ELEMS(cv_pix_fmts); i++) {

156 if (cv_pix_fmts[i].pix_fmt == pix_fmt) {

157 int full_range = (range == AVCOL_RANGE_JPEG);

158

159 // Don't care if unspecified

160 if (range == AVCOL_RANGE_UNSPECIFIED)

161 return cv_pix_fmts[i].cv_fmt;

162

163 if (cv_pix_fmts[i].full_range == full_range)

164 return cv_pix_fmts[i].cv_fmt;

165 }

166 }

167

168 return 0;

169 }

170

171 uint32_t av_map_videotoolbox_format_from_pixfmt(enum AVPixelFormat pix_fmt)

172 {

173 return av_map_videotoolbox_format_from_pixfmt2(pix_fmt, false);

174 }

175

176 uint32_t av_map_videotoolbox_format_from_pixfmt2(enum AVPixelFormat pix_fmt, bool full_range)

177 {

178 return vt_format_from_pixfmt(pix_fmt, full_range ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG);

179 }

180

181 static int vt_pool_alloc(AVHWFramesContext *ctx)

182 {

183 VTFramesContext *fctx = ctx->hwctx;

184 AVVTFramesContext *hw_ctx = &fctx->p;

185 CVReturn err;

186 CFNumberRef w, h, pixfmt;

187 uint32_t cv_pixfmt;

188 CFMutableDictionaryRef attributes, iosurface_properties;

189

190 attributes = CFDictionaryCreateMutable(

191 NULL,

192 2,

193 &kCFTypeDictionaryKeyCallBacks,

194 &kCFTypeDictionaryValueCallBacks);

195

196 cv_pixfmt = vt_format_from_pixfmt(ctx->sw_format, hw_ctx->color_range);

197 pixfmt = CFNumberCreate(NULL, kCFNumberSInt32Type, &cv_pixfmt);

198 CFDictionarySetValue(

199 attributes,

200 kCVPixelBufferPixelFormatTypeKey,

201 pixfmt);

202 CFRelease(pixfmt);

203

204 iosurface_properties = CFDictionaryCreateMutable(

205 NULL,

206 0,

207 &kCFTypeDictionaryKeyCallBacks,

208 &kCFTypeDictionaryValueCallBacks);

209 CFDictionarySetValue(attributes, kCVPixelBufferIOSurfacePropertiesKey, iosurface_properties);

210 CFRelease(iosurface_properties);

211

212 w = CFNumberCreate(NULL, kCFNumberSInt32Type, &ctx->width);

213 h = CFNumberCreate(NULL, kCFNumberSInt32Type, &ctx->height);

214 CFDictionarySetValue(attributes, kCVPixelBufferWidthKey, w);

215 CFDictionarySetValue(attributes, kCVPixelBufferHeightKey, h);

216 CFRelease(w);

217 CFRelease(h);

218

219 err = CVPixelBufferPoolCreate(

220 NULL,

221 NULL,

222 attributes,

223 &fctx->pool);

224 CFRelease(attributes);

225

226 if (err == kCVReturnSuccess)

227 return 0;

228

229 av_log(ctx, AV_LOG_ERROR, "Error creating CVPixelBufferPool: %d\n", err);

230 return AVERROR_EXTERNAL;

231 }

232

233 static void videotoolbox_buffer_release(void *opaque, uint8_t *data)

234 {

235 CVPixelBufferRelease((CVPixelBufferRef)data);

236 }

237

238 static AVBufferRef *vt_pool_alloc_buffer(void *opaque, size_t size)

239 {

240 CVPixelBufferRef pixbuf;

241 AVBufferRef *buf;

242 CVReturn err;

243 AVHWFramesContext *ctx = opaque;

244 VTFramesContext *fctx = ctx->hwctx;

245

246 err = CVPixelBufferPoolCreatePixelBuffer(

247 NULL,

248 fctx->pool,

249 &pixbuf

250 );

251 if (err != kCVReturnSuccess) {

252 av_log(ctx, AV_LOG_ERROR, "Failed to create pixel buffer from pool: %d\n", err);

253 return NULL;

254 }

255

256 buf = av_buffer_create((uint8_t *)pixbuf, size,

257 videotoolbox_buffer_release, NULL, 0);

258 if (!buf) {

259 CVPixelBufferRelease(pixbuf);

260 return NULL;

261 }

262 return buf;

263 }

264

265 static void vt_frames_uninit(AVHWFramesContext *ctx)

266 {

267 VTFramesContext *fctx = ctx->hwctx;

268 if (fctx->pool) {

269 CVPixelBufferPoolRelease(fctx->pool);

270 fctx->pool = NULL;

271 }

272 }

273

274 static int vt_frames_init(AVHWFramesContext *ctx)

275 {

276 int i, ret;

277

278 for (i = 0; i < FF_ARRAY_ELEMS(supported_formats); i++) {

279 if (ctx->sw_format == supported_formats[i])

280 break;

281 }

282 if (i == FF_ARRAY_ELEMS(supported_formats)) {

283 av_log(ctx, AV_LOG_ERROR, "Pixel format '%s' is not supported\n",

284 av_get_pix_fmt_name(ctx->sw_format));

285 return AVERROR(ENOSYS);

286 }

287

288 if (!ctx->pool) {

289 ffhwframesctx(ctx)->pool_internal = av_buffer_pool_init2(

290 sizeof(CVPixelBufferRef), ctx, vt_pool_alloc_buffer, NULL);

291 if (!ffhwframesctx(ctx)->pool_internal)

292 return AVERROR(ENOMEM);

293 }

294

295 ret = vt_pool_alloc(ctx);

296 if (ret < 0)

297 return ret;

298

299 return 0;

300 }

301

302 static int vt_get_buffer(AVHWFramesContext *ctx, AVFrame *frame)

303 {

304 frame->buf[0] = av_buffer_pool_get(ctx->pool);

305 if (!frame->buf[0])

306 return AVERROR(ENOMEM);

307

308 frame->data[3] = frame->buf[0]->data;

309 frame->format = AV_PIX_FMT_VIDEOTOOLBOX;

310 frame->width = ctx->width;

311 frame->height = ctx->height;

312

313 return 0;

314 }

315

316 static int vt_transfer_get_formats(AVHWFramesContext *ctx,

317 enum AVHWFrameTransferDirection dir,

318 enum AVPixelFormat **formats)

319 {

320 enum AVPixelFormat *fmts = av_malloc_array(2, sizeof(*fmts));

321 if (!fmts)

322 return AVERROR(ENOMEM);

323

324 fmts[0] = ctx->sw_format;

325 fmts[1] = AV_PIX_FMT_NONE;

326

327 *formats = fmts;

328 return 0;

329 }

330

331 static void vt_unmap(AVHWFramesContext *ctx, HWMapDescriptor *hwmap)

332 {

333 CVPixelBufferRef pixbuf = (CVPixelBufferRef)hwmap->source->data[3];

334

335 CVPixelBufferUnlockBaseAddress(pixbuf, (uintptr_t)hwmap->priv);

336 }

337

338 static int vt_pixbuf_set_par(void *log_ctx,

339 CVPixelBufferRef pixbuf, const AVFrame *src)

340 {

341 CFMutableDictionaryRef par = NULL;

342 CFNumberRef num = NULL, den = NULL;

343 AVRational avpar = src->sample_aspect_ratio;

344

345 if (avpar.num == 0) {

346 CVBufferRemoveAttachment(pixbuf, kCVImageBufferPixelAspectRatioKey);

347 return 0;

348 }

349

350 av_reduce(&avpar.num, &avpar.den,

351 avpar.num, avpar.den,

352 0xFFFFFFFF);

353

354 num = CFNumberCreate(kCFAllocatorDefault,

355 kCFNumberIntType,

356 &avpar.num);

357

358 den = CFNumberCreate(kCFAllocatorDefault,

359 kCFNumberIntType,

360 &avpar.den);

361

362 par = CFDictionaryCreateMutable(kCFAllocatorDefault,

363 2,

364 &kCFCopyStringDictionaryKeyCallBacks,

365 &kCFTypeDictionaryValueCallBacks);

366

367 if (!par || !num || !den) {

368 if (par) CFRelease(par);

369 if (num) CFRelease(num);

370 if (den) CFRelease(den);

371 return AVERROR(ENOMEM);

372 }

373

374 CFDictionarySetValue(

375 par,

376 kCVImageBufferPixelAspectRatioHorizontalSpacingKey,

377 num);

378 CFDictionarySetValue(

379 par,

380 kCVImageBufferPixelAspectRatioVerticalSpacingKey,

381 den);

382

383 CVBufferSetAttachment(

384 pixbuf,

385 kCVImageBufferPixelAspectRatioKey,

386 par,

387 kCVAttachmentMode_ShouldPropagate

388 );

389

390 CFRelease(par);

391 CFRelease(num);

392 CFRelease(den);

393

394 return 0;

395 }

396

397 CFStringRef av_map_videotoolbox_chroma_loc_from_av(enum AVChromaLocation loc)

398 {

399 switch (loc) {

400 case AVCHROMA_LOC_LEFT:

401 return kCVImageBufferChromaLocation_Left;

402 case AVCHROMA_LOC_CENTER:

403 return kCVImageBufferChromaLocation_Center;

404 case AVCHROMA_LOC_TOP:

405 return kCVImageBufferChromaLocation_Top;

406 case AVCHROMA_LOC_BOTTOM:

407 return kCVImageBufferChromaLocation_Bottom;

408 case AVCHROMA_LOC_TOPLEFT:

409 return kCVImageBufferChromaLocation_TopLeft;

410 case AVCHROMA_LOC_BOTTOMLEFT:

411 return kCVImageBufferChromaLocation_BottomLeft;

412 default:

413 return NULL;

414 }

415 }

416

417 static int vt_pixbuf_set_chromaloc(void *log_ctx,

418 CVPixelBufferRef pixbuf, const AVFrame *src)

419 {

420 CFStringRef loc = av_map_videotoolbox_chroma_loc_from_av(src->chroma_location);

421

422 if (loc) {

423 CVBufferSetAttachment(

424 pixbuf,

425 kCVImageBufferChromaLocationTopFieldKey,

426 loc,

427 kCVAttachmentMode_ShouldPropagate);

428 } else

429 CVBufferRemoveAttachment(

430 pixbuf,

431 kCVImageBufferChromaLocationTopFieldKey);

432

433 return 0;

434 }

435

436 CFStringRef av_map_videotoolbox_color_matrix_from_av(enum AVColorSpace space)

437 {

438 switch (space) {

439 case AVCOL_SPC_BT2020_CL:

440 case AVCOL_SPC_BT2020_NCL:

441 #if HAVE_KCVIMAGEBUFFERYCBCRMATRIX_ITU_R_2020

442 if (__builtin_available(macOS 10.11, iOS 9, *))

443 return kCVImageBufferYCbCrMatrix_ITU_R_2020;

444 #endif

445 return CFSTR("ITU_R_2020");

446 case AVCOL_SPC_BT470BG:

447 case AVCOL_SPC_SMPTE170M:

448 return kCVImageBufferYCbCrMatrix_ITU_R_601_4;

449 case AVCOL_SPC_BT709:

450 return kCVImageBufferYCbCrMatrix_ITU_R_709_2;

451 case AVCOL_SPC_SMPTE240M:

452 return kCVImageBufferYCbCrMatrix_SMPTE_240M_1995;

453 default:

454 #if HAVE_KCVIMAGEBUFFERTRANSFERFUNCTION_ITU_R_2100_HLG

455 if (__builtin_available(macOS 10.13, iOS 11, tvOS 11, watchOS 4, *))

456 return CVYCbCrMatrixGetStringForIntegerCodePoint(space);

457 #endif

458 case AVCOL_SPC_UNSPECIFIED:

459 return NULL;

460 }

461 }

462

463 CFStringRef av_map_videotoolbox_color_primaries_from_av(enum AVColorPrimaries pri)

464 {

465 switch (pri) {

466 case AVCOL_PRI_BT2020:

467 #if HAVE_KCVIMAGEBUFFERCOLORPRIMARIES_ITU_R_2020

468 if (__builtin_available(macOS 10.11, iOS 9, *))

469 return kCVImageBufferColorPrimaries_ITU_R_2020;

470 #endif

471 return CFSTR("ITU_R_2020");

472 case AVCOL_PRI_BT709:

473 return kCVImageBufferColorPrimaries_ITU_R_709_2;

474 case AVCOL_PRI_SMPTE170M:

475 return kCVImageBufferColorPrimaries_SMPTE_C;

476 case AVCOL_PRI_BT470BG:

477 return kCVImageBufferColorPrimaries_EBU_3213;

478 default:

479 #if HAVE_KCVIMAGEBUFFERTRANSFERFUNCTION_ITU_R_2100_HLG

480 if (__builtin_available(macOS 10.13, iOS 11, tvOS 11, watchOS 4, *))

481 return CVColorPrimariesGetStringForIntegerCodePoint(pri);

482 #endif

483 case AVCOL_PRI_UNSPECIFIED:

484 return NULL;

485 }

486 }

487

488 CFStringRef av_map_videotoolbox_color_trc_from_av(enum AVColorTransferCharacteristic trc)

489 {

490

491 switch (trc) {

492 case AVCOL_TRC_SMPTE2084:

493 #if HAVE_KCVIMAGEBUFFERTRANSFERFUNCTION_SMPTE_ST_2084_PQ

494 if (__builtin_available(macOS 10.13, iOS 11, *))

495 return kCVImageBufferTransferFunction_SMPTE_ST_2084_PQ;

496 #endif

497 return CFSTR("SMPTE_ST_2084_PQ");

498 case AVCOL_TRC_BT2020_10:

499 case AVCOL_TRC_BT2020_12:

500 #if HAVE_KCVIMAGEBUFFERTRANSFERFUNCTION_ITU_R_2020

501 if (__builtin_available(macOS 10.11, iOS 9, *))

502 return kCVImageBufferTransferFunction_ITU_R_2020;

503 #endif

504 return CFSTR("ITU_R_2020");

505 case AVCOL_TRC_BT709:

506 return kCVImageBufferTransferFunction_ITU_R_709_2;

507 case AVCOL_TRC_SMPTE240M:

508 return kCVImageBufferTransferFunction_SMPTE_240M_1995;

509 case AVCOL_TRC_SMPTE428:

510 #if HAVE_KCVIMAGEBUFFERTRANSFERFUNCTION_SMPTE_ST_428_1

511 if (__builtin_available(macOS 10.12, iOS 10, *))

512 return kCVImageBufferTransferFunction_SMPTE_ST_428_1;

513 #endif

514 return CFSTR("SMPTE_ST_428_1");

515 case AVCOL_TRC_ARIB_STD_B67:

516 #if HAVE_KCVIMAGEBUFFERTRANSFERFUNCTION_ITU_R_2100_HLG

517 if (__builtin_available(macOS 10.13, iOS 11, *))

518 return kCVImageBufferTransferFunction_ITU_R_2100_HLG;

519 #endif

520 return CFSTR("ITU_R_2100_HLG");

521 case AVCOL_TRC_GAMMA22:

522 return kCVImageBufferTransferFunction_UseGamma;

523 case AVCOL_TRC_GAMMA28:

524 return kCVImageBufferTransferFunction_UseGamma;

525 default:

526 #if HAVE_KCVIMAGEBUFFERTRANSFERFUNCTION_ITU_R_2100_HLG

527 if (__builtin_available(macOS 10.13, iOS 11, tvOS 11, watchOS 4, *))

528 return CVTransferFunctionGetStringForIntegerCodePoint(trc);

529 #endif

530 case AVCOL_TRC_UNSPECIFIED:

531 return NULL;

532 }

533 }

534

535 /**

536 * Copy all attachments for the specified mode from the given buffer.

537 */

538 static CFDictionaryRef vt_cv_buffer_copy_attachments(CVBufferRef buffer,

539 CVAttachmentMode attachment_mode)

540 {

541 CFDictionaryRef dict;

542

543 // Check that our SDK is at least macOS 12 / iOS 15 / tvOS 15

544 #if (TARGET_OS_OSX && defined(__MAC_12_0) && __MAC_OS_X_VERSION_MAX_ALLOWED >= __MAC_12_0) || \

545 (TARGET_OS_IOS && defined(__IPHONE_15_0) && __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_15_0) || \

546 (TARGET_OS_TV && defined(__TVOS_15_0) && __TV_OS_VERSION_MAX_ALLOWED >= __TVOS_15_0)

547 // On recent enough versions, just use the respective API

548 if (__builtin_available(macOS 12.0, iOS 15.0, tvOS 15.0, *))

549 return CVBufferCopyAttachments(buffer, attachment_mode);

550 #endif

551

552 // Check that the target is lower than macOS 12 / iOS 15 / tvOS 15

553 // else this would generate a deprecation warning and anyway never run because

554 // the runtime availability check above would be always true.

555 #if (TARGET_OS_OSX && (!defined(__MAC_12_0) || __MAC_OS_X_VERSION_MIN_REQUIRED < __MAC_12_0)) || \

556 (TARGET_OS_IOS && (!defined(__IPHONE_15_0) || __IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_15_0)) || \

557 (TARGET_OS_TV && (!defined(__TVOS_15_0) || __TV_OS_VERSION_MIN_REQUIRED < __TVOS_15_0))

558 // Fallback on SDKs or runtime versions < macOS 12 / iOS 15 / tvOS 15

559 dict = CVBufferGetAttachments(buffer, attachment_mode);

560 return (dict) ? CFDictionaryCreateCopy(NULL, dict) : NULL;

561 #else

562 return NULL; // Impossible, just make the compiler happy

563 #endif

564 }

565

566 static int vt_pixbuf_set_colorspace(void *log_ctx,

567 CVPixelBufferRef pixbuf, const AVFrame *src)

568 {

569 CGColorSpaceRef colorspace = NULL;

570 CFStringRef colormatrix = NULL, colorpri = NULL, colortrc = NULL;

571 Float32 gamma = 0;

572

573 colormatrix = av_map_videotoolbox_color_matrix_from_av(src->colorspace);

574 if (colormatrix)

575 CVBufferSetAttachment(pixbuf, kCVImageBufferYCbCrMatrixKey,

576 colormatrix, kCVAttachmentMode_ShouldPropagate);

577 else {

578 CVBufferRemoveAttachment(pixbuf, kCVImageBufferYCbCrMatrixKey);

579 if (src->colorspace != AVCOL_SPC_UNSPECIFIED && src->colorspace != AVCOL_SPC_RGB)

580 av_log(log_ctx, AV_LOG_WARNING,

581 "Color space %s is not supported.\n",

582 av_color_space_name(src->colorspace));

583 }

584

585 colorpri = av_map_videotoolbox_color_primaries_from_av(src->color_primaries);

586 if (colorpri)

587 CVBufferSetAttachment(pixbuf, kCVImageBufferColorPrimariesKey,

588 colorpri, kCVAttachmentMode_ShouldPropagate);

589 else {

590 CVBufferRemoveAttachment(pixbuf, kCVImageBufferColorPrimariesKey);

591 if (src->color_primaries != AVCOL_SPC_UNSPECIFIED)

592 av_log(log_ctx, AV_LOG_WARNING,

593 "Color primaries %s is not supported.\n",

594 av_color_primaries_name(src->color_primaries));

595 }

596

597 colortrc = av_map_videotoolbox_color_trc_from_av(src->color_trc);

598 if (colortrc)

599 CVBufferSetAttachment(pixbuf, kCVImageBufferTransferFunctionKey,

600 colortrc, kCVAttachmentMode_ShouldPropagate);

601 else {

602 CVBufferRemoveAttachment(pixbuf, kCVImageBufferTransferFunctionKey);

603 if (src->color_trc != AVCOL_TRC_UNSPECIFIED)

604 av_log(log_ctx, AV_LOG_WARNING,

605 "Color transfer function %s is not supported.\n",

606 av_color_transfer_name(src->color_trc));

607 }

608

609 if (src->color_trc == AVCOL_TRC_GAMMA22)

610 gamma = 2.2;

611 else if (src->color_trc == AVCOL_TRC_GAMMA28)

612 gamma = 2.8;

613

614 if (gamma != 0) {

615 CFNumberRef gamma_level = CFNumberCreate(NULL, kCFNumberFloat32Type, &gamma);

616 CVBufferSetAttachment(pixbuf, kCVImageBufferGammaLevelKey,

617 gamma_level, kCVAttachmentMode_ShouldPropagate);

618 CFRelease(gamma_level);

619 } else

620 CVBufferRemoveAttachment(pixbuf, kCVImageBufferGammaLevelKey);

621

622 #if (TARGET_OS_OSX && __MAC_OS_X_VERSION_MAX_ALLOWED >= 100800) || \

623 (TARGET_OS_IOS && __IPHONE_OS_VERSION_MAX_ALLOWED >= 100000)

624 if (__builtin_available(macOS 10.8, iOS 10, *)) {

625 CFDictionaryRef attachments =

626 vt_cv_buffer_copy_attachments(pixbuf, kCVAttachmentMode_ShouldPropagate);

627

628 if (attachments) {

629 colorspace =

630 CVImageBufferCreateColorSpaceFromAttachments(attachments);

631 CFRelease(attachments);

632 }

633 }

634 #endif

635

636 // Done outside the above preprocessor code and if's so that

637 // in any case a wrong kCVImageBufferCGColorSpaceKey is removed

638 // if the above code is not used or fails.

639 if (colorspace) {

640 CVBufferSetAttachment(pixbuf, kCVImageBufferCGColorSpaceKey,

641 colorspace, kCVAttachmentMode_ShouldPropagate);

642 CFRelease(colorspace);

643 } else

644 CVBufferRemoveAttachment(pixbuf, kCVImageBufferCGColorSpaceKey);

645

646 return 0;

647 }

648

649 static int vt_pixbuf_set_attachments(void *log_ctx,

650 CVPixelBufferRef pixbuf, const AVFrame *src)

651 {

652 int ret;

653 ret = vt_pixbuf_set_par(log_ctx, pixbuf, src);

654 if (ret < 0)

655 return ret;

656 ret = vt_pixbuf_set_colorspace(log_ctx, pixbuf, src);

657 if (ret < 0)

658 return ret;

659 ret = vt_pixbuf_set_chromaloc(log_ctx, pixbuf, src);

660 if (ret < 0)

661 return ret;

662 return 0;

663 }

664

665 int av_vt_pixbuf_set_attachments(void *log_ctx,

666 CVPixelBufferRef pixbuf, const AVFrame *src)

667 {

668 return vt_pixbuf_set_attachments(log_ctx, pixbuf, src);

669 }

670

671 static int vt_map_frame(AVHWFramesContext *ctx, AVFrame *dst, const AVFrame *src,

672 int flags)

673 {

674 CVPixelBufferRef pixbuf = (CVPixelBufferRef)src->data[3];

675 OSType pixel_format = CVPixelBufferGetPixelFormatType(pixbuf);

676 CVReturn err;

677 uint32_t map_flags = 0;

678 int ret;

679 int i;

680 enum AVPixelFormat format;

681

682 format = av_map_videotoolbox_format_to_pixfmt(pixel_format);

683 if (dst->format != format) {

684 av_log(ctx, AV_LOG_ERROR, "Unsupported or mismatching pixel format: %s\n",

685 av_fourcc2str(pixel_format));

686 return AVERROR_UNKNOWN;

687 }

688

689 if (CVPixelBufferGetWidth(pixbuf) != ctx->width ||

690 CVPixelBufferGetHeight(pixbuf) != ctx->height) {

691 av_log(ctx, AV_LOG_ERROR, "Inconsistent frame dimensions.\n");

692 return AVERROR_UNKNOWN;

693 }

694

695 if (flags == AV_HWFRAME_MAP_READ)

696 map_flags = kCVPixelBufferLock_ReadOnly;

697

698 err = CVPixelBufferLockBaseAddress(pixbuf, map_flags);

699 if (err != kCVReturnSuccess) {

700 av_log(ctx, AV_LOG_ERROR, "Error locking the pixel buffer.\n");

701 return AVERROR_UNKNOWN;

702 }

703

704 if (CVPixelBufferIsPlanar(pixbuf)) {

705 int planes = CVPixelBufferGetPlaneCount(pixbuf);

706 for (i = 0; i < planes; i++) {

707 dst->data[i] = CVPixelBufferGetBaseAddressOfPlane(pixbuf, i);

708 dst->linesize[i] = CVPixelBufferGetBytesPerRowOfPlane(pixbuf, i);

709 }

710 } else {

711 dst->data[0] = CVPixelBufferGetBaseAddress(pixbuf);

712 dst->linesize[0] = CVPixelBufferGetBytesPerRow(pixbuf);

713 }

714

715 ret = ff_hwframe_map_create(src->hw_frames_ctx, dst, src, vt_unmap,

716 (void *)(uintptr_t)map_flags);

717 if (ret < 0)

718 goto unlock;

719

720 return 0;

721

722 unlock:

723 CVPixelBufferUnlockBaseAddress(pixbuf, map_flags);

724 return ret;

725 }

726

727 static int vt_transfer_data_from(AVHWFramesContext *hwfc,

728 AVFrame *dst, const AVFrame *src)

729 {

730 AVFrame *map;

731 int err;

732

733 if (dst->width > hwfc->width || dst->height > hwfc->height)

734 return AVERROR(EINVAL);

735

736 map = av_frame_alloc();

737 if (!map)

738 return AVERROR(ENOMEM);

739 map->format = dst->format;

740

741 err = vt_map_frame(hwfc, map, src, AV_HWFRAME_MAP_READ);

742 if (err)

743 goto fail;

744

745 map->width = dst->width;

746 map->height = dst->height;

747

748 err = av_frame_copy(dst, map);

749 if (err)

750 goto fail;

751

752 err = 0;

753 fail:

754 av_frame_free(&map);

755 return err;

756 }

757

758 static int vt_transfer_data_to(AVHWFramesContext *hwfc,

759 AVFrame *dst, const AVFrame *src)

760 {

761 AVFrame *map;

762 int err;

763

764 if (src->width > hwfc->width || src->height > hwfc->height)

765 return AVERROR(EINVAL);

766

767 map = av_frame_alloc();

768 if (!map)

769 return AVERROR(ENOMEM);

770 map->format = src->format;

771

772 err = vt_map_frame(hwfc, map, dst, AV_HWFRAME_MAP_WRITE | AV_HWFRAME_MAP_OVERWRITE);

773 if (err)

774 goto fail;

775

776 map->width = src->width;

777 map->height = src->height;

778

779 err = av_frame_copy(map, src);

780 if (err)

781 goto fail;

782

783 err = vt_pixbuf_set_attachments(hwfc, (CVPixelBufferRef)dst->data[3], src);

784 if (err)

785 goto fail;

786

787 err = 0;

788 fail:

789 av_frame_free(&map);

790 return err;

791 }

792

793 static int vt_map_from(AVHWFramesContext *hwfc, AVFrame *dst,

794 const AVFrame *src, int flags)

795 {

796 int err;

797

798 if (dst->format == AV_PIX_FMT_NONE)

799 dst->format = hwfc->sw_format;

800 else if (dst->format != hwfc->sw_format)

801 return AVERROR(ENOSYS);

802

803 err = vt_map_frame(hwfc, dst, src, flags);

804 if (err)

805 return err;

806

807 dst->width = src->width;

808 dst->height = src->height;

809

810 err = av_frame_copy_props(dst, src);

811 if (err)

812 return err;

813

814 return 0;

815 }

816

817 static int vt_device_create(AVHWDeviceContext *ctx, const char *device,

818 AVDictionary *opts, int flags)

819 {

820 if (device && device[0]) {

821 av_log(ctx, AV_LOG_ERROR, "Device selection unsupported.\n");

822 return AVERROR_UNKNOWN;

823 }

824

825 return 0;

826 }

827

828 const HWContextType ff_hwcontext_type_videotoolbox = {

829 .type = AV_HWDEVICE_TYPE_VIDEOTOOLBOX,

830 .name = "videotoolbox",

831

832 .frames_hwctx_size = sizeof(VTFramesContext),

833

834 .device_create = vt_device_create,

835 .frames_init = vt_frames_init,

836 .frames_get_buffer = vt_get_buffer,

837 .frames_get_constraints = vt_frames_get_constraints,

838 .frames_uninit = vt_frames_uninit,

839 .transfer_get_formats = vt_transfer_get_formats,

840 .transfer_data_to = vt_transfer_data_to,

841 .transfer_data_from = vt_transfer_data_from,

842 .map_from = vt_map_from,

843

844 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_VIDEOTOOLBOX, AV_PIX_FMT_NONE },

845 };

formats

Definition: signature.h:47

FFHWFramesContext::pool_internal

AVBufferPool * pool_internal

Definition: hwcontext_internal.h:101

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

AVPixelFormat

Pixel format.

Definition: pixfmt.h:71

av_map_videotoolbox_color_trc_from_av

CFStringRef av_map_videotoolbox_color_trc_from_av(enum AVColorTransferCharacteristic trc)

Convert an AVColorTransferCharacteristic to a VideoToolbox/CoreVideo color transfer function string.

Definition: hwcontext_videotoolbox.c:488

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

kCVPixelFormatType_420YpCbCr10BiPlanarFullRange

@ kCVPixelFormatType_420YpCbCr10BiPlanarFullRange

Definition: videotoolboxenc.c:53

space

Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated space

Definition: undefined.txt:4

AVColorTransferCharacteristic

Color Transfer Characteristic.

Definition: pixfmt.h:580

HWMapDescriptor::source

AVFrame * source

A reference to the original source of the mapping.

Definition: hwcontext_internal.h:124

av_map_videotoolbox_color_matrix_from_av

CFStringRef av_map_videotoolbox_color_matrix_from_av(enum AVColorSpace space)

Convert an AVColorSpace to a VideoToolbox/CoreVideo color matrix string.

Definition: hwcontext_videotoolbox.c:436

vt_transfer_data_from

static int vt_transfer_data_from(AVHWFramesContext *hwfc, AVFrame *dst, const AVFrame *src)

Definition: hwcontext_videotoolbox.c:727

AVCHROMA_LOC_BOTTOM

@ AVCHROMA_LOC_BOTTOM

Definition: pixfmt.h:712

av_frame_free

void av_frame_free(AVFrame **frame)

Free the frame and any dynamically allocated objects in it, e.g.

Definition: frame.c:162

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:389

pix_fmt

enum AVPixelFormat pix_fmt

Definition: hwcontext_videotoolbox.c:47

buffer_internal.h

pixdesc.h

uint8_t w

Definition: llviddspenc.c:38

AVCOL_RANGE_JPEG

@ AVCOL_RANGE_JPEG

Full range content.

Definition: pixfmt.h:686

AVCOL_TRC_UNSPECIFIED

@ AVCOL_TRC_UNSPECIFIED

Definition: pixfmt.h:583

av_vt_pixbuf_set_attachments

int av_vt_pixbuf_set_attachments(void *log_ctx, CVPixelBufferRef pixbuf, const AVFrame *src)

Definition: hwcontext_videotoolbox.c:665

data

const char data[16]

Definition: mxf.c:148

AVCOL_SPC_RGB

@ AVCOL_SPC_RGB

order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB), YZX and ST 428-1

Definition: pixfmt.h:610

AVCOL_TRC_BT2020_12

@ AVCOL_TRC_BT2020_12

ITU-R BT2020 for 12-bit system.

Definition: pixfmt.h:596

vt_frames_init

static int vt_frames_init(AVHWFramesContext *ctx)

Definition: hwcontext_videotoolbox.c:274

AV_PIX_FMT_BGRA

@ AV_PIX_FMT_BGRA

packed BGRA 8:8:8:8, 32bpp, BGRABGRA...

Definition: pixfmt.h:102

AVDictionary

Definition: dict.c:34

ff_hwframe_map_create

int ff_hwframe_map_create(AVBufferRef *hwframe_ref, AVFrame *dst, const AVFrame *src, void(*unmap)(AVHWFramesContext *ctx, HWMapDescriptor *hwmap), void *priv)

Definition: hwcontext.c:726

AV_HWDEVICE_TYPE_VIDEOTOOLBOX

@ AV_HWDEVICE_TYPE_VIDEOTOOLBOX

Definition: hwcontext.h:34

AVColorPrimaries

Chromaticity coordinates of the source primaries.

Definition: pixfmt.h:555

vt_map_frame

static int vt_map_frame(AVHWFramesContext *ctx, AVFrame *dst, const AVFrame *src, int flags)

Definition: hwcontext_videotoolbox.c:671

HWMapDescriptor::priv

void * priv

Hardware-specific private data associated with the mapping.

Definition: hwcontext_internal.h:139

AVHWFramesConstraints::valid_hw_formats

enum AVPixelFormat * valid_hw_formats

A list of possible values for format in the hw_frames_ctx, terminated by AV_PIX_FMT_NONE.

Definition: hwcontext.h:446

AVERROR_UNKNOWN

#define AVERROR_UNKNOWN

Unknown error, typically from an external library.

Definition: error.h:73

AVHWFramesContext::width

int width

The allocated dimensions of the frames in this pool.

Definition: hwcontext.h:217

AV_HWFRAME_MAP_READ

@ AV_HWFRAME_MAP_READ

The mapping must be readable.

Definition: hwcontext.h:512

VTFramesContext::pool

CVPixelBufferPoolRef pool

Definition: hwcontext_videotoolbox.c:41

AVCOL_SPC_BT2020_CL

@ AVCOL_SPC_BT2020_CL

ITU-R BT2020 constant luminance system.

Definition: pixfmt.h:621

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:410

ff_hwcontext_type_videotoolbox

const HWContextType ff_hwcontext_type_videotoolbox

Definition: hwcontext_videotoolbox.c:828

AVHWFramesConstraints

This struct describes the constraints on hardware frames attached to a given device with a hardware-s...

Definition: hwcontext.h:441

vt_pixbuf_set_attachments

static int vt_pixbuf_set_attachments(void *log_ctx, CVPixelBufferRef pixbuf, const AVFrame *src)

Definition: hwcontext_videotoolbox.c:649

AVCOL_SPC_BT470BG

@ AVCOL_SPC_BT470BG

also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601

Definition: pixfmt.h:615

av_color_space_name

const char * av_color_space_name(enum AVColorSpace space)

Definition: pixdesc.c:3341

fail

#define fail()

Definition: checkasm.h:188

AVCOL_TRC_GAMMA28

@ AVCOL_TRC_GAMMA28

also ITU-R BT470BG

Definition: pixfmt.h:586

av_buffer_pool_init2

AVBufferPool * av_buffer_pool_init2(size_t size, void *opaque, AVBufferRef *(*alloc)(void *opaque, size_t size), void(*pool_free)(void *opaque))

Allocate and initialize a buffer pool with a more complex allocator.

Definition: buffer.c:259

kCVImageBufferYCbCrMatrix_ITU_R_2020

CFStringRef kCVImageBufferYCbCrMatrix_ITU_R_2020

Definition: videotoolboxenc.c:86

vt_device_create

static int vt_device_create(AVHWDeviceContext *ctx, const char *device, AVDictionary *opts, int flags)

Definition: hwcontext_videotoolbox.c:817

av_reduce

int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)

Reduce a fraction.

Definition: rational.c:35

AVRational::num

int num

Numerator.

Definition: rational.h:59

vt_frames_uninit

static void vt_frames_uninit(AVHWFramesContext *ctx)

Definition: hwcontext_videotoolbox.c:265

AVCOL_TRC_GAMMA22

@ AVCOL_TRC_GAMMA22

also ITU-R BT470M / ITU-R BT1700 625 PAL & SECAM

Definition: pixfmt.h:585

AVHWDeviceContext

This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.

Definition: hwcontext.h:60

av_frame_alloc

AVFrame * av_frame_alloc(void)

Allocate an AVFrame and set its fields to default values.

Definition: frame.c:150

av_map_videotoolbox_color_primaries_from_av

CFStringRef av_map_videotoolbox_color_primaries_from_av(enum AVColorPrimaries pri)

Convert an AVColorPrimaries to a VideoToolbox/CoreVideo color primaries string.

Definition: hwcontext_videotoolbox.c:463

HWContextType::type

enum AVHWDeviceType type

Definition: hwcontext_internal.h:30

ffhwframesctx

static FFHWFramesContext * ffhwframesctx(AVHWFramesContext *ctx)

Definition: hwcontext_internal.h:115

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen.c:29

AVHWFramesContext::height

int height

Definition: hwcontext.h:217

AVHWFramesConstraints::valid_sw_formats

enum AVPixelFormat * valid_sw_formats

A list of possible values for sw_format in the hw_frames_ctx, terminated by AV_PIX_FMT_NONE.

Definition: hwcontext.h:453

vt_pixbuf_set_chromaloc

static int vt_pixbuf_set_chromaloc(void *log_ctx, CVPixelBufferRef pixbuf, const AVFrame *src)

Definition: hwcontext_videotoolbox.c:417

av_buffer_pool_get

AVBufferRef * av_buffer_pool_get(AVBufferPool *pool)

Allocate a new AVBuffer, reusing an old buffer from the pool when available.

Definition: buffer.c:390

full_range

bool full_range

Definition: hwcontext_videotoolbox.c:46

AVCHROMA_LOC_TOP

@ AVCHROMA_LOC_TOP

Definition: pixfmt.h:710

supported_formats

static enum AVPixelFormat supported_formats[]

Definition: hwcontext_videotoolbox.c:86

format

AVCOL_SPC_SMPTE170M

@ AVCOL_SPC_SMPTE170M

also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC / functionally identical to above

Definition: pixfmt.h:616

vt_transfer_get_formats

static int vt_transfer_get_formats(AVHWFramesContext *ctx, enum AVHWFrameTransferDirection dir, enum AVPixelFormat **formats)

Definition: hwcontext_videotoolbox.c:316

pix_fmts

static enum AVPixelFormat pix_fmts[]

Definition: libkvazaar.c:304

ctx

AVFormatContext * ctx

Definition: movenc.c:49

AV_PIX_FMT_YUV420P

@ AV_PIX_FMT_YUV420P

planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)

Definition: pixfmt.h:73

AVCOL_PRI_UNSPECIFIED

@ AVCOL_PRI_UNSPECIFIED

Definition: pixfmt.h:558

AVVTFramesContext

Definition: hwcontext_videotoolbox.h:45

AVCOL_PRI_BT470BG

@ AVCOL_PRI_BT470BG

also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM

Definition: pixfmt.h:562

vt_pixbuf_set_colorspace

static int vt_pixbuf_set_colorspace(void *log_ctx, CVPixelBufferRef pixbuf, const AVFrame *src)

Definition: hwcontext_videotoolbox.c:566

AVCOL_PRI_SMPTE170M

@ AVCOL_PRI_SMPTE170M

also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC

Definition: pixfmt.h:563

opts

AVDictionary * opts

Definition: movenc.c:51

NULL

#define NULL

Definition: coverity.c:32

AVHWFramesContext::sw_format

enum AVPixelFormat sw_format

The pixel format identifying the actual data layout of the hardware frames.

Definition: hwcontext.h:210

av_frame_copy_props

int av_frame_copy_props(AVFrame *dst, const AVFrame *src)

Copy only "metadata" fields from src to dst.

Definition: frame.c:713

vt_map_from

static int vt_map_from(AVHWFramesContext *hwfc, AVFrame *dst, const AVFrame *src, int flags)

Definition: hwcontext_videotoolbox.c:793

cv_fmt

uint32_t cv_fmt

Definition: hwcontext_videotoolbox.c:45

av_map_videotoolbox_format_from_pixfmt

uint32_t av_map_videotoolbox_format_from_pixfmt(enum AVPixelFormat pix_fmt)

Convert an AVPixelFormat to a VideoToolbox (actually CoreVideo) format.

Definition: hwcontext_videotoolbox.c:171

AVVTFramesContext::color_range

enum AVColorRange color_range

Definition: hwcontext_videotoolbox.h:46

AVCHROMA_LOC_LEFT

@ AVCHROMA_LOC_LEFT

MPEG-2/4 4:2:0, H.264 default for 4:2:0.

Definition: pixfmt.h:707

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

AVCHROMA_LOC_TOPLEFT

@ AVCHROMA_LOC_TOPLEFT

ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2.

Definition: pixfmt.h:709

AVCOL_PRI_BT709

@ AVCOL_PRI_BT709

also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP 177 Annex B

Definition: pixfmt.h:557

AV_PIX_FMT_P410

#define AV_PIX_FMT_P410

Definition: pixfmt.h:540

av_color_primaries_name

const char * av_color_primaries_name(enum AVColorPrimaries primaries)

Definition: pixdesc.c:3299

AVCOL_TRC_BT2020_10

@ AVCOL_TRC_BT2020_10

ITU-R BT2020 for 10-bit system.

Definition: pixfmt.h:595

vt_pool_alloc_buffer

static AVBufferRef * vt_pool_alloc_buffer(void *opaque, size_t size)

Definition: hwcontext_videotoolbox.c:238

AVCOL_RANGE_UNSPECIFIED

@ AVCOL_RANGE_UNSPECIFIED

Definition: pixfmt.h:652

vt_cv_buffer_copy_attachments

static CFDictionaryRef vt_cv_buffer_copy_attachments(CVBufferRef buffer, CVAttachmentMode attachment_mode)

Copy all attachments for the specified mode from the given buffer.

Definition: hwcontext_videotoolbox.c:538

av_buffer_create

AVBufferRef * av_buffer_create(uint8_t *data, size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)

Create an AVBuffer from an existing array.

Definition: buffer.c:55

AVCOL_PRI_BT2020

@ AVCOL_PRI_BT2020

ITU-R BT2020.

Definition: pixfmt.h:566

AVCOL_TRC_SMPTE2084

@ AVCOL_TRC_SMPTE2084

SMPTE ST 2084 for 10-, 12-, 14- and 16-bit systems.

Definition: pixfmt.h:597

hwcontext_videotoolbox.h

AVCOL_TRC_SMPTE240M

@ AVCOL_TRC_SMPTE240M

Definition: pixfmt.h:588

vt_pixbuf_set_par

static int vt_pixbuf_set_par(void *log_ctx, CVPixelBufferRef pixbuf, const AVFrame *src)

Definition: hwcontext_videotoolbox.c:338

dst

uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst

Definition: dsp.h:83

av_frame_copy

int av_frame_copy(AVFrame *dst, const AVFrame *src)

Copy the frame data from src to dst.

Definition: frame.c:1003

kCVImageBufferTransferFunction_ITU_R_2020

CFStringRef kCVImageBufferTransferFunction_ITU_R_2020

Definition: videotoolboxenc.c:85

size

int size

Definition: twinvq_data.h:10344

AV_PIX_FMT_AYUV64

#define AV_PIX_FMT_AYUV64

Definition: pixfmt.h:527

range

enum AVColorRange range

Definition: mediacodec_wrapper.c:2464

AV_PIX_FMT_NV16

@ AV_PIX_FMT_NV16

interleaved chroma YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)

Definition: pixfmt.h:198

buffer.h

vt_frames_get_constraints

static int vt_frames_get_constraints(AVHWDeviceContext *ctx, const void *hwconfig, AVHWFramesConstraints *constraints)

Definition: hwcontext_videotoolbox.c:117

AVERROR_EXTERNAL

#define AVERROR_EXTERNAL

Generic error in an external library.

Definition: error.h:59

AV_PIX_FMT_P216

#define AV_PIX_FMT_P216

Definition: pixfmt.h:543

AV_PIX_FMT_P210

#define AV_PIX_FMT_P210

Definition: pixfmt.h:539

vt_unmap

static void vt_unmap(AVHWFramesContext *ctx, HWMapDescriptor *hwmap)

Definition: hwcontext_videotoolbox.c:331

vt_transfer_data_to

static int vt_transfer_data_to(AVHWFramesContext *hwfc, AVFrame *dst, const AVFrame *src)

Definition: hwcontext_videotoolbox.c:758

AVCOL_TRC_BT709

@ AVCOL_TRC_BT709

also ITU-R BT1361

Definition: pixfmt.h:582

cv_pix_fmts

static const struct @443 cv_pix_fmts[]

AVChromaLocation

Location of chroma samples.

Definition: pixfmt.h:705

AVCOL_SPC_SMPTE240M

@ AVCOL_SPC_SMPTE240M

derived from 170M primaries and D65 white point, 170M is derived from BT470 System M's primaries

Definition: pixfmt.h:617

AV_PIX_FMT_VIDEOTOOLBOX

@ AV_PIX_FMT_VIDEOTOOLBOX

hardware decoding through Videotoolbox

Definition: pixfmt.h:305

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:256

AVCOL_SPC_BT2020_NCL

@ AVCOL_SPC_BT2020_NCL

ITU-R BT2020 non-constant luminance system.

Definition: pixfmt.h:620

av_malloc_array

#define av_malloc_array(a, b)

Definition: tableprint_vlc.h:31

AVColorSpace

YUV colorspace type.

Definition: pixfmt.h:609

AV_PIX_FMT_NV24

@ AV_PIX_FMT_NV24

planar YUV 4:4:4, 24bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...

Definition: pixfmt.h:371

common.h

AV_HWFRAME_MAP_WRITE

@ AV_HWFRAME_MAP_WRITE

The mapping must be writeable.

Definition: hwcontext.h:516

AVCOL_SPC_UNSPECIFIED

@ AVCOL_SPC_UNSPECIFIED

Definition: pixfmt.h:612

AVCOL_RANGE_MPEG

@ AVCOL_RANGE_MPEG

Narrow or limited range content.

Definition: pixfmt.h:669

AVHWFrameTransferDirection

Definition: hwcontext.h:403

AVHWFramesContext

This struct describes a set or pool of "hardware" frames (i.e.

Definition: hwcontext.h:115

vt_get_buffer

static int vt_get_buffer(AVHWFramesContext *ctx, AVFrame *frame)

Definition: hwcontext_videotoolbox.c:302

videotoolbox_buffer_release

static void videotoolbox_buffer_release(void *opaque, uint8_t *data)

Definition: hwcontext_videotoolbox.c:233

ret

Definition: filter_design.txt:187

pixfmt

enum AVPixelFormat pixfmt

Definition: kmsgrab.c:367

pixfmt.h

AV_PIX_FMT_NV12

@ AV_PIX_FMT_NV12

planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...

Definition: pixfmt.h:96

frame

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame

Definition: filter_design.txt:264

av_map_videotoolbox_format_to_pixfmt

enum AVPixelFormat av_map_videotoolbox_format_to_pixfmt(uint32_t cv_fmt)

Convert a VideoToolbox (actually CoreVideo) format to AVPixelFormat.

Definition: hwcontext_videotoolbox.c:142

AV_PIX_FMT_UYVY422

@ AV_PIX_FMT_UYVY422

packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1

Definition: pixfmt.h:88

AVCOL_TRC_ARIB_STD_B67

@ AVCOL_TRC_ARIB_STD_B67

ARIB STD-B67, known as "Hybrid log-gamma".

Definition: pixfmt.h:601

kCVImageBufferColorPrimaries_ITU_R_2020

CFStringRef kCVImageBufferColorPrimaries_ITU_R_2020

Definition: videotoolboxenc.c:84

planes

static const struct @455 planes[]

buffer

the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer

Definition: filter_design.txt:49

AVCHROMA_LOC_CENTER

@ AVCHROMA_LOC_CENTER

MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0.

Definition: pixfmt.h:708

AVRational::den

int den

Denominator.

Definition: rational.h:60

AV_PIX_FMT_NONE

@ AV_PIX_FMT_NONE

Definition: pixfmt.h:72