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 return 0;

347

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

349 avpar.num, avpar.den,

350 0xFFFFFFFF);

351

352 num = CFNumberCreate(kCFAllocatorDefault,

353 kCFNumberIntType,

354 &avpar.num);

355

356 den = CFNumberCreate(kCFAllocatorDefault,

357 kCFNumberIntType,

358 &avpar.den);

359

360 par = CFDictionaryCreateMutable(kCFAllocatorDefault,

361 2,

362 &kCFCopyStringDictionaryKeyCallBacks,

363 &kCFTypeDictionaryValueCallBacks);

364

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

366 if (par) CFRelease(par);

367 if (num) CFRelease(num);

368 if (den) CFRelease(den);

369 return AVERROR(ENOMEM);

370 }

371

372 CFDictionarySetValue(

373 par,

374 kCVImageBufferPixelAspectRatioHorizontalSpacingKey,

375 num);

376 CFDictionarySetValue(

377 par,

378 kCVImageBufferPixelAspectRatioVerticalSpacingKey,

379 den);

380

381 CVBufferSetAttachment(

382 pixbuf,

383 kCVImageBufferPixelAspectRatioKey,

384 par,

385 kCVAttachmentMode_ShouldPropagate

386 );

387

388 CFRelease(par);

389 CFRelease(num);

390 CFRelease(den);

391

392 return 0;

393 }

394

395 CFStringRef av_map_videotoolbox_chroma_loc_from_av(enum AVChromaLocation loc)

396 {

397 switch (loc) {

398 case AVCHROMA_LOC_LEFT:

399 return kCVImageBufferChromaLocation_Left;

400 case AVCHROMA_LOC_CENTER:

401 return kCVImageBufferChromaLocation_Center;

402 case AVCHROMA_LOC_TOP:

403 return kCVImageBufferChromaLocation_Top;

404 case AVCHROMA_LOC_BOTTOM:

405 return kCVImageBufferChromaLocation_Bottom;

406 case AVCHROMA_LOC_TOPLEFT:

407 return kCVImageBufferChromaLocation_TopLeft;

408 case AVCHROMA_LOC_BOTTOMLEFT:

409 return kCVImageBufferChromaLocation_BottomLeft;

410 default:

411 return NULL;

412 }

413 }

414

415 static int vt_pixbuf_set_chromaloc(void *log_ctx,

416 CVPixelBufferRef pixbuf, const AVFrame *src)

417 {

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

419

420 if (loc) {

421 CVBufferSetAttachment(

422 pixbuf,

423 kCVImageBufferChromaLocationTopFieldKey,

424 loc,

425 kCVAttachmentMode_ShouldPropagate);

426 }

427

428 return 0;

429 }

430

431 CFStringRef av_map_videotoolbox_color_matrix_from_av(enum AVColorSpace space)

432 {

433 switch (space) {

434 case AVCOL_SPC_BT2020_CL:

435 case AVCOL_SPC_BT2020_NCL:

436 #if HAVE_KCVIMAGEBUFFERYCBCRMATRIX_ITU_R_2020

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

438 return kCVImageBufferYCbCrMatrix_ITU_R_2020;

439 #endif

440 return CFSTR("ITU_R_2020");

441 case AVCOL_SPC_BT470BG:

442 case AVCOL_SPC_SMPTE170M:

443 return kCVImageBufferYCbCrMatrix_ITU_R_601_4;

444 case AVCOL_SPC_BT709:

445 return kCVImageBufferYCbCrMatrix_ITU_R_709_2;

446 case AVCOL_SPC_SMPTE240M:

447 return kCVImageBufferYCbCrMatrix_SMPTE_240M_1995;

448 default:

449 #if HAVE_KCVIMAGEBUFFERTRANSFERFUNCTION_ITU_R_2100_HLG

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

451 return CVYCbCrMatrixGetStringForIntegerCodePoint(space);

452 #endif

453 case AVCOL_SPC_UNSPECIFIED:

454 return NULL;

455 }

456 }

457

458 CFStringRef av_map_videotoolbox_color_primaries_from_av(enum AVColorPrimaries pri)

459 {

460 switch (pri) {

461 case AVCOL_PRI_BT2020:

462 #if HAVE_KCVIMAGEBUFFERCOLORPRIMARIES_ITU_R_2020

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

464 return kCVImageBufferColorPrimaries_ITU_R_2020;

465 #endif

466 return CFSTR("ITU_R_2020");

467 case AVCOL_PRI_BT709:

468 return kCVImageBufferColorPrimaries_ITU_R_709_2;

469 case AVCOL_PRI_SMPTE170M:

470 return kCVImageBufferColorPrimaries_SMPTE_C;

471 case AVCOL_PRI_BT470BG:

472 return kCVImageBufferColorPrimaries_EBU_3213;

473 default:

474 #if HAVE_KCVIMAGEBUFFERTRANSFERFUNCTION_ITU_R_2100_HLG

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

476 return CVColorPrimariesGetStringForIntegerCodePoint(pri);

477 #endif

478 case AVCOL_PRI_UNSPECIFIED:

479 return NULL;

480 }

481 }

482

483 CFStringRef av_map_videotoolbox_color_trc_from_av(enum AVColorTransferCharacteristic trc)

484 {

485

486 switch (trc) {

487 case AVCOL_TRC_SMPTE2084:

488 #if HAVE_KCVIMAGEBUFFERTRANSFERFUNCTION_SMPTE_ST_2084_PQ

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

490 return kCVImageBufferTransferFunction_SMPTE_ST_2084_PQ;

491 #endif

492 return CFSTR("SMPTE_ST_2084_PQ");

493 case AVCOL_TRC_BT2020_10:

494 case AVCOL_TRC_BT2020_12:

495 #if HAVE_KCVIMAGEBUFFERTRANSFERFUNCTION_ITU_R_2020

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

497 return kCVImageBufferTransferFunction_ITU_R_2020;

498 #endif

499 return CFSTR("ITU_R_2020");

500 case AVCOL_TRC_BT709:

501 return kCVImageBufferTransferFunction_ITU_R_709_2;

502 case AVCOL_TRC_SMPTE240M:

503 return kCVImageBufferTransferFunction_SMPTE_240M_1995;

504 case AVCOL_TRC_SMPTE428:

505 #if HAVE_KCVIMAGEBUFFERTRANSFERFUNCTION_SMPTE_ST_428_1

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

507 return kCVImageBufferTransferFunction_SMPTE_ST_428_1;

508 #endif

509 return CFSTR("SMPTE_ST_428_1");

510 case AVCOL_TRC_ARIB_STD_B67:

511 #if HAVE_KCVIMAGEBUFFERTRANSFERFUNCTION_ITU_R_2100_HLG

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

513 return kCVImageBufferTransferFunction_ITU_R_2100_HLG;

514 #endif

515 return CFSTR("ITU_R_2100_HLG");

516 case AVCOL_TRC_GAMMA22:

517 return kCVImageBufferTransferFunction_UseGamma;

518 case AVCOL_TRC_GAMMA28:

519 return kCVImageBufferTransferFunction_UseGamma;

520 default:

521 #if HAVE_KCVIMAGEBUFFERTRANSFERFUNCTION_ITU_R_2100_HLG

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

523 return CVTransferFunctionGetStringForIntegerCodePoint(trc);

524 #endif

525 case AVCOL_TRC_UNSPECIFIED:

526 return NULL;

527 }

528 }

529

530 static int vt_pixbuf_set_colorspace(void *log_ctx,

531 CVPixelBufferRef pixbuf, const AVFrame *src)

532 {

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

534 Float32 gamma = 0;

535

536 colormatrix = av_map_videotoolbox_color_matrix_from_av(src->colorspace);

537 if (!colormatrix && src->colorspace != AVCOL_SPC_UNSPECIFIED)

538 av_log(log_ctx, AV_LOG_WARNING, "Color space %s is not supported.\n", av_color_space_name(src->colorspace));

539

540 colorpri = av_map_videotoolbox_color_primaries_from_av(src->color_primaries);

541 if (!colorpri && src->color_primaries != AVCOL_PRI_UNSPECIFIED)

542 av_log(log_ctx, AV_LOG_WARNING, "Color primaries %s is not supported.\n", av_color_primaries_name(src->color_primaries));

543

544 colortrc = av_map_videotoolbox_color_trc_from_av(src->color_trc);

545 if (!colortrc && src->color_trc != AVCOL_TRC_UNSPECIFIED)

546 av_log(log_ctx, AV_LOG_WARNING, "Color transfer function %s is not supported.\n", av_color_transfer_name(src->color_trc));

547

548 if (src->color_trc == AVCOL_TRC_GAMMA22)

549 gamma = 2.2;

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

551 gamma = 2.8;

552

553 if (colormatrix) {

554 CVBufferSetAttachment(

555 pixbuf,

556 kCVImageBufferYCbCrMatrixKey,

557 colormatrix,

558 kCVAttachmentMode_ShouldPropagate);

559 }

560 if (colorpri) {

561 CVBufferSetAttachment(

562 pixbuf,

563 kCVImageBufferColorPrimariesKey,

564 colorpri,

565 kCVAttachmentMode_ShouldPropagate);

566 }

567 if (colortrc) {

568 CVBufferSetAttachment(

569 pixbuf,

570 kCVImageBufferTransferFunctionKey,

571 colortrc,

572 kCVAttachmentMode_ShouldPropagate);

573 }

574 if (gamma != 0) {

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

576 CVBufferSetAttachment(

577 pixbuf,

578 kCVImageBufferGammaLevelKey,

579 gamma_level,

580 kCVAttachmentMode_ShouldPropagate);

581 CFRelease(gamma_level);

582 }

583

584 return 0;

585 }

586

587 static int vt_pixbuf_set_attachments(void *log_ctx,

588 CVPixelBufferRef pixbuf, const AVFrame *src)

589 {

590 int ret;

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

592 if (ret < 0)

593 return ret;

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

595 if (ret < 0)

596 return ret;

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

598 if (ret < 0)

599 return ret;

600 return 0;

601 }

602

603 int av_vt_pixbuf_set_attachments(void *log_ctx,

604 CVPixelBufferRef pixbuf, const AVFrame *src)

605 {

606 return vt_pixbuf_set_attachments(log_ctx, pixbuf, src);

607 }

608

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

610 int flags)

611 {

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

613 OSType pixel_format = CVPixelBufferGetPixelFormatType(pixbuf);

614 CVReturn err;

615 uint32_t map_flags = 0;

616 int ret;

617 int i;

618 enum AVPixelFormat format;

619

620 format = av_map_videotoolbox_format_to_pixfmt(pixel_format);

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

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

623 av_fourcc2str(pixel_format));

624 return AVERROR_UNKNOWN;

625 }

626

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

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

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

630 return AVERROR_UNKNOWN;

631 }

632

633 if (flags == AV_HWFRAME_MAP_READ)

634 map_flags = kCVPixelBufferLock_ReadOnly;

635

636 err = CVPixelBufferLockBaseAddress(pixbuf, map_flags);

637 if (err != kCVReturnSuccess) {

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

639 return AVERROR_UNKNOWN;

640 }

641

642 if (CVPixelBufferIsPlanar(pixbuf)) {

643 int planes = CVPixelBufferGetPlaneCount(pixbuf);

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

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

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

647 }

648 } else {

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

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

651 }

652

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

654 (void *)(uintptr_t)map_flags);

655 if (ret < 0)

656 goto unlock;

657

658 return 0;

659

660 unlock:

661 CVPixelBufferUnlockBaseAddress(pixbuf, map_flags);

662 return ret;

663 }

664

665 static int vt_transfer_data_from(AVHWFramesContext *hwfc,

666 AVFrame *dst, const AVFrame *src)

667 {

668 AVFrame *map;

669 int err;

670

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

672 return AVERROR(EINVAL);

673

674 map = av_frame_alloc();

675 if (!map)

676 return AVERROR(ENOMEM);

677 map->format = dst->format;

678

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

680 if (err)

681 goto fail;

682

683 map->width = dst->width;

684 map->height = dst->height;

685

686 err = av_frame_copy(dst, map);

687 if (err)

688 goto fail;

689

690 err = 0;

691 fail:

692 av_frame_free(&map);

693 return err;

694 }

695

696 static int vt_transfer_data_to(AVHWFramesContext *hwfc,

697 AVFrame *dst, const AVFrame *src)

698 {

699 AVFrame *map;

700 int err;

701

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

703 return AVERROR(EINVAL);

704

705 map = av_frame_alloc();

706 if (!map)

707 return AVERROR(ENOMEM);

708 map->format = src->format;

709

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

711 if (err)

712 goto fail;

713

714 map->width = src->width;

715 map->height = src->height;

716

717 err = av_frame_copy(map, src);

718 if (err)

719 goto fail;

720

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

722 if (err)

723 goto fail;

724

725 err = 0;

726 fail:

727 av_frame_free(&map);

728 return err;

729 }

730

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

732 const AVFrame *src, int flags)

733 {

734 int err;

735

736 if (dst->format == AV_PIX_FMT_NONE)

737 dst->format = hwfc->sw_format;

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

739 return AVERROR(ENOSYS);

740

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

742 if (err)

743 return err;

744

745 dst->width = src->width;

746 dst->height = src->height;

747

748 err = av_frame_copy_props(dst, src);

749 if (err)

750 return err;

751

752 return 0;

753 }

754

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

756 AVDictionary *opts, int flags)

757 {

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

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

760 return AVERROR_UNKNOWN;

761 }

762

763 return 0;

764 }

765

766 const HWContextType ff_hwcontext_type_videotoolbox = {

767 .type = AV_HWDEVICE_TYPE_VIDEOTOOLBOX,

768 .name = "videotoolbox",

769

770 .frames_hwctx_size = sizeof(VTFramesContext),

771

772 .device_create = vt_device_create,

773 .frames_init = vt_frames_init,

774 .frames_get_buffer = vt_get_buffer,

775 .frames_get_constraints = vt_frames_get_constraints,

776 .frames_uninit = vt_frames_uninit,

777 .transfer_get_formats = vt_transfer_get_formats,

778 .transfer_data_to = vt_transfer_data_to,

779 .transfer_data_from = vt_transfer_data_from,

780 .map_from = vt_map_from,

781

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

783 };

formats

Definition: signature.h:48

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:483

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

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:431

vt_transfer_data_from

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

Definition: hwcontext_videotoolbox.c:665

AVBufferRef::data

uint8_t * data

The data buffer.

Definition: buffer.h:90

AVCHROMA_LOC_BOTTOM

@ AVCHROMA_LOC_BOTTOM

Definition: pixfmt.h:709

av_frame_free

void av_frame_free(AVFrame **frame)

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

Definition: frame.c:130

AVFrame

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

Definition: frame.h:344

pix_fmt

enum AVPixelFormat pix_fmt

Definition: hwcontext_videotoolbox.c:47

buffer_internal.h

pixdesc.h

AVFrame::width

int width

Definition: frame.h:416

uint8_t w

Definition: llviddspenc.c:38

AVCOL_RANGE_JPEG

@ AVCOL_RANGE_JPEG

Full range content.

Definition: pixfmt.h:683

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:603

data

const char data[16]

Definition: mxf.c:148

cv_pix_fmts

static const struct @374 cv_pix_fmts[]

kCVPixelFormatType_420YpCbCr10BiPlanarVideoRange

@ kCVPixelFormatType_420YpCbCr10BiPlanarVideoRange

Definition: videotoolboxenc.c:53

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:609

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

AVFrame::buf

AVBufferRef * buf[AV_NUM_DATA_POINTERS]

AVBuffer references backing the data for this frame.

Definition: frame.h:557

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:365

ff_hwcontext_type_videotoolbox

const HWContextType ff_hwcontext_type_videotoolbox

Definition: hwcontext_videotoolbox.c:766

AV_HWFRAME_MAP_OVERWRITE

@ AV_HWFRAME_MAP_OVERWRITE

The mapped frame will be overwritten completely in subsequent operations, so the current frame data n...

Definition: hwcontext.h:522

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:587

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:3338

fail

#define fail()

Definition: checkasm.h:179

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:85

vt_device_create

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

Definition: hwcontext_videotoolbox.c:755

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:118

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:458

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:415

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

kCVPixelFormatType_420YpCbCr10BiPlanarFullRange

@ kCVPixelFormatType_420YpCbCr10BiPlanarFullRange

Definition: videotoolboxenc.c:52

AVCHROMA_LOC_TOP

@ AVCHROMA_LOC_TOP

Definition: pixfmt.h:707

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:48

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

frame

static AVFrame * frame

Definition: demux_decode.c:54

vt_pixbuf_set_colorspace

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

Definition: hwcontext_videotoolbox.c:530

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:50

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:679

vt_map_from

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

Definition: hwcontext_videotoolbox.c:731

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:704

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:706

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:3296

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:649

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

av_frame_copy

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

Copy the frame data from src to dst.

Definition: frame.c:890

kCVImageBufferTransferFunction_ITU_R_2020

CFStringRef kCVImageBufferTransferFunction_ITU_R_2020

Definition: videotoolboxenc.c:84

size

int size

Definition: twinvq_data.h:10344

AV_PIX_FMT_AYUV64

#define AV_PIX_FMT_AYUV64

Definition: pixfmt.h:527

AVFrame::format

int format

format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...

Definition: frame.h:431

range

enum AVColorRange range

Definition: mediacodec_wrapper.c:2557

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:696

AVCOL_TRC_BT709

@ AVCOL_TRC_BT709

also ITU-R BT1361

Definition: pixfmt.h:582

AVChromaLocation

Location of chroma samples.

Definition: pixfmt.h:702

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:255

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

AVCOL_SPC_UNSPECIFIED

@ AVCOL_SPC_UNSPECIFIED

Definition: pixfmt.h:612

AVCOL_RANGE_MPEG

@ AVCOL_RANGE_MPEG

Narrow or limited range content.

Definition: pixfmt.h:666

AVHWFrameTransferDirection

Definition: hwcontext.h:403

AVHWFramesContext

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

Definition: hwcontext.h:115

AV_HWFRAME_MAP_READ

@ AV_HWFRAME_MAP_READ

The mapping must be readable.

Definition: hwcontext.h:512

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:366

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

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

AVFrame::height

int height

Definition: frame.h:416

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:83

AVCHROMA_LOC_CENTER

@ AVCHROMA_LOC_CENTER

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

Definition: pixfmt.h:705

AVRational::den

int den

Denominator.

Definition: rational.h:60

AV_PIX_FMT_NONE

@ AV_PIX_FMT_NONE

Definition: pixfmt.h:72

AV_PIX_FMT_P010

#define AV_PIX_FMT_P010

Definition: pixfmt.h:528

av_map_videotoolbox_chroma_loc_from_av

CFStringRef av_map_videotoolbox_chroma_loc_from_av(enum AVChromaLocation loc)

Convert an AVChromaLocation to a VideoToolbox/CoreVideo chroma location string.

Definition: hwcontext_videotoolbox.c:395

mem.h

AVBufferRef

A reference to a data buffer.

Definition: buffer.h:82

hwcontext_internal.h

map

const VDPAUPixFmtMap * map

Definition: hwcontext_vdpau.c:71

planes

static const struct @386 planes[]

AV_PIX_FMT_P416

#define AV_PIX_FMT_P416

Definition: pixfmt.h:544

src

INIT_CLIP pixel * src

Definition: h264pred_template.c:418

av_map_videotoolbox_format_from_pixfmt2

uint32_t av_map_videotoolbox_format_from_pixfmt2(enum AVPixelFormat pix_fmt, bool full_range)

Same as av_map_videotoolbox_format_from_pixfmt function, but can map and return full range pixel form...

Definition: hwcontext_videotoolbox.c:176

flags

#define flags(name, subs,...)

Definition: cbs_av1.c:482

hwcontext.h

AVFrame::linesize

int linesize[AV_NUM_DATA_POINTERS]

For video, a positive or negative value, which is typically indicating the size in bytes of each pict...

Definition: frame.h:389

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:27

HWContextType

Definition: hwcontext_internal.h:29

vt_format_from_pixfmt

static uint32_t vt_format_from_pixfmt(enum AVPixelFormat pix_fmt, enum AVColorRange range)

Definition: hwcontext_videotoolbox.c:152

AVCOL_TRC_SMPTE428

@ AVCOL_TRC_SMPTE428

SMPTE ST 428-1.

Definition: pixfmt.h:599

AV_HWFRAME_MAP_WRITE

@ AV_HWFRAME_MAP_WRITE

The mapping must be writeable.

Definition: hwcontext.h:516

Definition: vp9dsp_template.c:2038

VTFramesContext

Definition: hwcontext_videotoolbox.c:36

AVCOL_SPC_BT709

@ AVCOL_SPC_BT709

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

Definition: pixfmt.h:611

AVColorRange

Visual content value range.

Definition: pixfmt.h:648

HWMapDescriptor

Definition: hwcontext_internal.h:120

av_color_transfer_name

const char * av_color_transfer_name(enum AVColorTransferCharacteristic transfer)

Definition: pixdesc.c:3317

AVCHROMA_LOC_BOTTOMLEFT

@ AVCHROMA_LOC_BOTTOMLEFT

Definition: pixfmt.h:708

vt_pool_alloc

static int vt_pool_alloc(AVHWFramesContext *ctx)

Definition: hwcontext_videotoolbox.c:181

VTFramesContext::p

AVVTFramesContext p

The public AVVTFramesContext.

Definition: hwcontext_videotoolbox.c:40

av_get_pix_fmt_name

const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)

Return the short name for a pixel format, NULL in case pix_fmt is unknown.

Definition: pixdesc.c:2882

av_fourcc2str

#define av_fourcc2str(fourcc)

Definition: avutil.h:345

Generated on Thu Sep 26 2024 23:15:55 for FFmpeg by doxygen 1.8.17