FFmpeg: libavcodec/videotoolbox.c Source File

FFmpeg

[フレーム]

libavcodec

videotoolbox.c

Go to the documentation of this file.

1 /*

2 * Videotoolbox hardware acceleration

3 *

5 *

6 * This file is part of FFmpeg.

7 *

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

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

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

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

12 *

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

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

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

16 * Lesser General Public License for more details.

17 *

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

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

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

21 */

23 #include "config.h"

24 #include "config_components.h"

25 #include "videotoolbox.h"

26 #include "libavutil/hwcontext_videotoolbox.h"

27 #include "libavutil/mem.h"

28 #include "vt_internal.h"

29 #include "libavutil/avutil.h"

30 #include "libavutil/hwcontext.h"

31 #include "libavutil/pixdesc.h"

32 #include "bytestream.h"

33 #include "decode.h"

34 #include "internal.h"

35 #include "h264dec.h"

36 #include "hevc/hevcdec.h"

37 #include "hwaccel_internal.h"

38 #include "mpegvideo.h"

39 #include "proresdec.h"

40 #include <Availability.h>

41 #include <AvailabilityMacros.h>

42 #include <TargetConditionals.h>

44 #ifndef kVTVideoDecoderSpecification_RequireHardwareAcceleratedVideoDecoder

45 # define kVTVideoDecoderSpecification_RequireHardwareAcceleratedVideoDecoder CFSTR("RequireHardwareAcceleratedVideoDecoder")

46 #endif

47 #ifndef kVTVideoDecoderSpecification_EnableHardwareAcceleratedVideoDecoder

48 # define kVTVideoDecoderSpecification_EnableHardwareAcceleratedVideoDecoder CFSTR("EnableHardwareAcceleratedVideoDecoder")

49 #endif

51 #if !HAVE_KCMVIDEOCODECTYPE_HEVC

52 enum { kCMVideoCodecType_HEVC = 'hvc1' };

53 #endif

55 #if !HAVE_KCMVIDEOCODECTYPE_VP9

56 enum { kCMVideoCodecType_VP9 = 'vp09' };

57 #endif

59 #define VIDEOTOOLBOX_ESDS_EXTRADATA_PADDING 12

61 typedef struct VTHWFrame {

62 CVPixelBufferRef pixbuf;

63 AVBufferRef *hw_frames_ctx;

64 } VTHWFrame;

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

67 {

68 VTHWFrame *ref = (VTHWFrame *)data;

69 av_buffer_unref(&ref->hw_frames_ctx);

70 CVPixelBufferRelease(ref->pixbuf);

72 av_free(data);

73 }

75 int ff_videotoolbox_buffer_copy(VTContext *vtctx,

76 const uint8_t *buffer,

77 uint32_t size)

78 {

79 void *tmp;

81 tmp = av_fast_realloc(vtctx->bitstream,

82 &vtctx->allocated_size,

83 size);

85 if (!tmp)

86 return AVERROR(ENOMEM);

88 vtctx->bitstream = tmp;

89 memcpy(vtctx->bitstream, buffer, size);

90 vtctx->bitstream_size = size;

92 return 0;

93 }

95 static int videotoolbox_postproc_frame(void *avctx, AVFrame *frame)

96 {

97 int ret;

98 VTHWFrame *ref = (VTHWFrame *)frame->buf[0]->data;

100 if (!ref->pixbuf) {

101 av_log(avctx, AV_LOG_ERROR, "No frame decoded?\n");

102 av_frame_unref(frame);

103 return AVERROR_EXTERNAL;

104 }

105

106 frame->crop_right = 0;

107 frame->crop_left = 0;

108 frame->crop_top = 0;

109 frame->crop_bottom = 0;

110

111 if ((ret = av_vt_pixbuf_set_attachments(avctx, ref->pixbuf, frame)) < 0)

112 return ret;

113

114 frame->data[3] = (uint8_t*)ref->pixbuf;

115

116 if (ref->hw_frames_ctx) {

117 av_buffer_unref(&frame->hw_frames_ctx);

118 frame->hw_frames_ctx = av_buffer_ref(ref->hw_frames_ctx);

119 if (!frame->hw_frames_ctx)

120 return AVERROR(ENOMEM);

121 }

122

123 return 0;

124 }

125

126 int ff_videotoolbox_alloc_frame(AVCodecContext *avctx, AVFrame *frame)

127 {

128 size_t size = sizeof(VTHWFrame);

129 uint8_t *data = NULL;

130 AVBufferRef *buf = NULL;

131 int ret = ff_attach_decode_data(frame);

132 FrameDecodeData *fdd;

133 if (ret < 0)

134 return ret;

135

136 data = av_mallocz(size);

137 if (!data)

138 return AVERROR(ENOMEM);

139 buf = av_buffer_create(data, size, videotoolbox_buffer_release, NULL, 0);

140 if (!buf) {

141 av_freep(&data);

142 return AVERROR(ENOMEM);

143 }

144 frame->buf[0] = buf;

145

146 fdd = (FrameDecodeData*)frame->private_ref->data;

147 fdd->post_process = videotoolbox_postproc_frame;

148

149 frame->width = avctx->width;

150 frame->height = avctx->height;

151 frame->format = avctx->pix_fmt;

152

153 return 0;

154 }

155

156 #define AV_W8(p, v) *(p) = (v)

157

158 static int escape_ps(uint8_t* dst, const uint8_t* src, int src_size)

159 {

160 int i;

161 int size = src_size;

162 uint8_t* p = dst;

163

164 for (i = 0; i < src_size; i++) {

165 if (i + 2 < src_size &&

166 src[i] == 0x00 &&

167 src[i + 1] == 0x00 &&

168 src[i + 2] <= 0x03) {

169 if (dst) {

170 *p++ = src[i++];

171 *p++ = src[i];

172 *p++ = 0x03;

173 } else {

174 i++;

175 }

176 size++;

177 } else if (dst)

178 *p++ = src[i];

179 }

180

181 if (dst)

182 av_assert0((p - dst) == size);

183

184 return size;

185 }

186

187 CFDataRef ff_videotoolbox_avcc_extradata_create(AVCodecContext *avctx)

188 {

189 VTContext *vtctx = avctx->internal->hwaccel_priv_data;

190 H264Context *h = avctx->priv_data;

191 CFDataRef data = NULL;

192 uint8_t *p;

193 int sps_size = escape_ps(NULL, h->ps.sps->data, h->ps.sps->data_size);

194 int pps_size = escape_ps(NULL, h->ps.pps->data, h->ps.pps->data_size);

195 int vt_extradata_size;

196 uint8_t *vt_extradata;

197

198 vt_extradata_size = 6 + 2 + sps_size + 3 + pps_size;

199 vt_extradata = av_malloc(vt_extradata_size);

200

201 if (!vt_extradata)

202 return NULL;

203

204 p = vt_extradata;

205

206 AV_W8(p + 0, 1); /* version */

207 AV_W8(p + 1, h->ps.sps->data[1]); /* profile */

208 AV_W8(p + 2, h->ps.sps->data[2]); /* profile compat */

209 AV_W8(p + 3, h->ps.sps->data[3]); /* level */

210 AV_W8(p + 4, 0xff); /* 6 bits reserved (111111) + 2 bits nal size length - 3 (11) */

211 AV_W8(p + 5, 0xe1); /* 3 bits reserved (111) + 5 bits number of sps (00001) */

212 AV_WB16(p + 6, sps_size);

213 p += 8;

214 p += escape_ps(p, h->ps.sps->data, h->ps.sps->data_size);

215 AV_W8(p + 0, 1); /* number of pps */

216 AV_WB16(p + 1, pps_size);

217 p += 3;

218 p += escape_ps(p, h->ps.pps->data, h->ps.pps->data_size);

219

220 av_assert0(p - vt_extradata == vt_extradata_size);

221

222 // save sps header (profile/level) used to create decoder session,

223 // so we can detect changes and recreate it.

224 if (vtctx)

225 memcpy(vtctx->sps, h->ps.sps->data + 1, 3);

226

227 data = CFDataCreate(kCFAllocatorDefault, vt_extradata, vt_extradata_size);

228 av_free(vt_extradata);

229 return data;

230 }

231

232 CFDataRef ff_videotoolbox_hvcc_extradata_create(AVCodecContext *avctx)

233 {

234 HEVCContext *h = avctx->priv_data;

235 int i, num_vps = 0, num_sps = 0, num_pps = 0;

236 const HEVCPPS *pps = h->pps;

237 const HEVCSPS *sps = pps->sps;

238 const HEVCVPS *vps = sps->vps;

239 PTLCommon ptlc = vps->ptl.general_ptl;

240 VUI vui = sps->vui;

241 uint8_t parallelismType;

242 CFDataRef data = NULL;

243 uint8_t *p;

244 int vt_extradata_size = 23 + 3 + 3 + 3;

245 uint8_t *vt_extradata;

246

247 #define COUNT_SIZE_PS(T, t) \

248 for (i = 0; i < HEVC_MAX_##T##PS_COUNT; i++) { \

249 if (h->ps.t##ps_list[i]) { \

250 const HEVC##T##PS *lps = h->ps.t##ps_list[i]; \

251 vt_extradata_size += 2 + escape_ps(NULL, lps->data, lps->data_size); \

252 num_##t##ps++; \

253 } \

254 }

255

256 COUNT_SIZE_PS(V, v)

257 COUNT_SIZE_PS(S, s)

258 COUNT_SIZE_PS(P, p)

259

260 vt_extradata = av_malloc(vt_extradata_size);

261 if (!vt_extradata)

262 return NULL;

263 p = vt_extradata;

264

265 /* unsigned int(8) configurationVersion = 1; */

266 AV_W8(p + 0, 1);

267

268 /*

269 * unsigned int(2) general_profile_space;

270 * unsigned int(1) general_tier_flag;

271 * unsigned int(5) general_profile_idc;

272 */

273 AV_W8(p + 1, ptlc.profile_space << 6 |

274 ptlc.tier_flag << 5 |

275 ptlc.profile_idc);

276

277 /* unsigned int(32) general_profile_compatibility_flags; */

278 for (i = 0; i < 4; i++) {

279 AV_W8(p + 2 + i, ptlc.profile_compatibility_flag[i * 8] << 7 |

280 ptlc.profile_compatibility_flag[i * 8 + 1] << 6 |

281 ptlc.profile_compatibility_flag[i * 8 + 2] << 5 |

282 ptlc.profile_compatibility_flag[i * 8 + 3] << 4 |

283 ptlc.profile_compatibility_flag[i * 8 + 4] << 3 |

284 ptlc.profile_compatibility_flag[i * 8 + 5] << 2 |

285 ptlc.profile_compatibility_flag[i * 8 + 6] << 1 |

286 ptlc.profile_compatibility_flag[i * 8 + 7]);

287 }

288

289 /* unsigned int(48) general_constraint_indicator_flags; */

290 AV_W8(p + 6, ptlc.progressive_source_flag << 7 |

291 ptlc.interlaced_source_flag << 6 |

292 ptlc.non_packed_constraint_flag << 5 |

293 ptlc.frame_only_constraint_flag << 4);

294 AV_W8(p + 7, 0);

295 AV_WN32(p + 8, 0);

296

297 /* unsigned int(8) general_level_idc; */

298 AV_W8(p + 12, ptlc.level_idc);

299

300 /*

301 * bit(4) reserved = ‘1111’b;

302 * unsigned int(12) min_spatial_segmentation_idc;

303 */

304 AV_W8(p + 13, 0xf0 | (vui.min_spatial_segmentation_idc >> 4));

305 AV_W8(p + 14, vui.min_spatial_segmentation_idc & 0xff);

306

307 /*

308 * bit(6) reserved = ‘111111’b;

309 * unsigned int(2) parallelismType;

310 */

311 if (!vui.min_spatial_segmentation_idc)

312 parallelismType = 0;

313 else if (pps->entropy_coding_sync_enabled_flag && pps->tiles_enabled_flag)

314 parallelismType = 0;

315 else if (pps->entropy_coding_sync_enabled_flag)

316 parallelismType = 3;

317 else if (pps->tiles_enabled_flag)

318 parallelismType = 2;

319 else

320 parallelismType = 1;

321 AV_W8(p + 15, 0xfc | parallelismType);

322

323 /*

324 * bit(6) reserved = ‘111111’b;

325 * unsigned int(2) chromaFormat;

326 */

327 AV_W8(p + 16, sps->chroma_format_idc | 0xfc);

328

329 /*

330 * bit(5) reserved = ‘11111’b;

331 * unsigned int(3) bitDepthLumaMinus8;

332 */

333 AV_W8(p + 17, (sps->bit_depth - 8) | 0xf8);

334

335 /*

336 * bit(5) reserved = ‘11111’b;

337 * unsigned int(3) bitDepthChromaMinus8;

338 */

339 AV_W8(p + 18, (sps->bit_depth_chroma - 8) | 0xf8);

340

341 /* bit(16) avgFrameRate; */

342 AV_WB16(p + 19, 0);

343

344 /*

345 * bit(2) constantFrameRate;

346 * bit(3) numTemporalLayers;

347 * bit(1) temporalIdNested;

348 * unsigned int(2) lengthSizeMinusOne;

349 */

350 AV_W8(p + 21, 0 << 6 |

351 sps->max_sub_layers << 3 |

352 sps->temporal_id_nesting << 2 |

353 3);

354

355 /* unsigned int(8) numOfArrays; */

356 AV_W8(p + 22, 3);

357

358 p += 23;

359

360 #define APPEND_PS(T, t) \

361 /* \

362 * bit(1) array_completeness; \

363 * unsigned int(1) reserved = 0; \

364 * unsigned int(6) NAL_unit_type; \

365 */ \

366 AV_W8(p, 1 << 7 | \

367 HEVC_NAL_##T##PS & 0x3f); \

368 /* unsigned int(16) numNalus; */ \

369 AV_WB16(p + 1, num_##t##ps); \

370 p += 3; \

371 for (i = 0; i < HEVC_MAX_##T##PS_COUNT; i++) { \

372 if (h->ps.t##ps_list[i]) { \

373 const HEVC##T##PS *lps = h->ps.t##ps_list[i]; \

374 int size = escape_ps(p + 2, lps->data, lps->data_size); \

375 /* unsigned int(16) nalUnitLength; */ \

376 AV_WB16(p, size); \

377 /* bit(8*nalUnitLength) nalUnit; */ \

378 p += 2 + size; \

379 } \

380 }

381

382 APPEND_PS(V, v)

383 APPEND_PS(S, s)

384 APPEND_PS(P, p)

385

386 av_assert0(p - vt_extradata == vt_extradata_size);

387

388 data = CFDataCreate(kCFAllocatorDefault, vt_extradata, vt_extradata_size);

389 av_free(vt_extradata);

390 return data;

391 }

392

393 int ff_videotoolbox_h264_start_frame(AVCodecContext *avctx,

394 const uint8_t *buffer,

395 uint32_t size)

396 {

397 VTContext *vtctx = avctx->internal->hwaccel_priv_data;

398 H264Context *h = avctx->priv_data;

399

400 if (h->is_avc == 1) {

401 return ff_videotoolbox_buffer_copy(vtctx, buffer, size);

402 }

403

404 return 0;

405 }

406

407 static int videotoolbox_h264_decode_params(AVCodecContext *avctx,

408 int type,

409 const uint8_t *buffer,

410 uint32_t size)

411 {

412 VTContext *vtctx = avctx->internal->hwaccel_priv_data;

413 H264Context *h = avctx->priv_data;

414

415 // save sps header (profile/level) used to create decoder session

416 if (!vtctx->sps[0])

417 memcpy(vtctx->sps, h->ps.sps->data + 1, 3);

418

419 if (type == H264_NAL_SPS) {

420 if (size > 4 && memcmp(vtctx->sps, buffer + 1, 3) != 0) {

421 vtctx->reconfig_needed = true;

422 memcpy(vtctx->sps, buffer + 1, 3);

423 }

424 }

425

426 // pass-through SPS/PPS changes to the decoder

427 return ff_videotoolbox_h264_decode_slice(avctx, buffer, size);

428 }

429

430 static int videotoolbox_common_decode_slice(AVCodecContext *avctx,

431 const uint8_t *buffer,

432 uint32_t size)

433 {

434 VTContext *vtctx = avctx->internal->hwaccel_priv_data;

435 void *tmp;

436

437 tmp = av_fast_realloc(vtctx->bitstream,

438 &vtctx->allocated_size,

439 vtctx->bitstream_size+size+4);

440 if (!tmp)

441 return AVERROR(ENOMEM);

442

443 vtctx->bitstream = tmp;

444

445 AV_WB32(vtctx->bitstream + vtctx->bitstream_size, size);

446 memcpy(vtctx->bitstream + vtctx->bitstream_size + 4, buffer, size);

447

448 vtctx->bitstream_size += size + 4;

449

450 return 0;

451 }

452

453 int ff_videotoolbox_h264_decode_slice(AVCodecContext *avctx,

454 const uint8_t *buffer,

455 uint32_t size)

456 {

457 H264Context *h = avctx->priv_data;

458

459 if (h->is_avc == 1)

460 return 0;

461

462 return videotoolbox_common_decode_slice(avctx, buffer, size);

463 }

464

465 #if CONFIG_VIDEOTOOLBOX

466 // Return the AVVideotoolboxContext that matters currently. Where it comes from

467 // depends on the API used.

468 static AVVideotoolboxContext *videotoolbox_get_context(AVCodecContext *avctx)

469 {

470 // Somewhat tricky because the user can call av_videotoolbox_default_free()

471 // at any time, even when the codec is closed.

472 if (avctx->internal && avctx->internal->hwaccel_priv_data) {

473 VTContext *vtctx = avctx->internal->hwaccel_priv_data;

474 if (vtctx->vt_ctx)

475 return vtctx->vt_ctx;

476 }

477 return avctx->hwaccel_context;

478 }

479

480 static void videotoolbox_stop(AVCodecContext *avctx)

481 {

482 AVVideotoolboxContext *videotoolbox = videotoolbox_get_context(avctx);

483 if (!videotoolbox)

484 return;

485

486 if (videotoolbox->cm_fmt_desc) {

487 CFRelease(videotoolbox->cm_fmt_desc);

488 videotoolbox->cm_fmt_desc = NULL;

489 }

490

491 if (videotoolbox->session) {

492 VTDecompressionSessionInvalidate(videotoolbox->session);

493 CFRelease(videotoolbox->session);

494 videotoolbox->session = NULL;

495 }

496 }

497

498 int ff_videotoolbox_uninit(AVCodecContext *avctx)

499 {

500 VTContext *vtctx = avctx->internal->hwaccel_priv_data;

501 if (!vtctx)

502 return 0;

503

504 av_freep(&vtctx->bitstream);

505 if (vtctx->frame)

506 CVPixelBufferRelease(vtctx->frame);

507

508 if (vtctx->vt_ctx)

509 videotoolbox_stop(avctx);

510

511 av_buffer_unref(&vtctx->cached_hw_frames_ctx);

512 av_freep(&vtctx->vt_ctx);

513

514 return 0;

515 }

516

517 static int videotoolbox_buffer_create(AVCodecContext *avctx, AVFrame *frame)

518 {

519 VTContext *vtctx = avctx->internal->hwaccel_priv_data;

520 CVPixelBufferRef pixbuf = (CVPixelBufferRef)vtctx->frame;

521 OSType pixel_format = CVPixelBufferGetPixelFormatType(pixbuf);

522 enum AVPixelFormat sw_format = av_map_videotoolbox_format_to_pixfmt(pixel_format);

523 int width = CVPixelBufferGetWidth(pixbuf);

524 int height = CVPixelBufferGetHeight(pixbuf);

525 AVHWFramesContext *cached_frames;

526 VTHWFrame *ref;

527 int ret;

528

529 if (!frame->buf[0] || frame->data[3]) {

530 av_log(avctx, AV_LOG_ERROR, "videotoolbox: invalid state\n");

531 av_frame_unref(frame);

532 return AVERROR_EXTERNAL;

533 }

534

535 ref = (VTHWFrame *)frame->buf[0]->data;

536

537 if (ref->pixbuf)

538 CVPixelBufferRelease(ref->pixbuf);

539 ref->pixbuf = vtctx->frame;

540 vtctx->frame = NULL;

541

542 // Old API code path.

543 if (!vtctx->cached_hw_frames_ctx)

544 return 0;

545

546 cached_frames = (AVHWFramesContext*)vtctx->cached_hw_frames_ctx->data;

547

548 if (cached_frames->sw_format != sw_format ||

549 cached_frames->width != width ||

550 cached_frames->height != height) {

551 AVBufferRef *hw_frames_ctx = av_hwframe_ctx_alloc(cached_frames->device_ref);

552 AVHWFramesContext *hw_frames;

553 AVVTFramesContext *hw_ctx;

554 if (!hw_frames_ctx)

555 return AVERROR(ENOMEM);

556

557 hw_frames = (AVHWFramesContext*)hw_frames_ctx->data;

558 hw_frames->format = cached_frames->format;

559 hw_frames->sw_format = sw_format;

560 hw_frames->width = width;

561 hw_frames->height = height;

562 hw_ctx = hw_frames->hwctx;

563 hw_ctx->color_range = avctx->color_range;

564

565 ret = av_hwframe_ctx_init(hw_frames_ctx);

566 if (ret < 0) {

567 av_buffer_unref(&hw_frames_ctx);

568 return ret;

569 }

570

571 av_buffer_unref(&vtctx->cached_hw_frames_ctx);

572 vtctx->cached_hw_frames_ctx = hw_frames_ctx;

573 }

574

575 av_buffer_unref(&ref->hw_frames_ctx);

576 ref->hw_frames_ctx = av_buffer_ref(vtctx->cached_hw_frames_ctx);

577 if (!ref->hw_frames_ctx)

578 return AVERROR(ENOMEM);

579

580 return 0;

581 }

582

583 static void videotoolbox_write_mp4_descr_length(PutByteContext *pb, int length)

584 {

585 int i;

586 uint8_t b;

587

588 for (i = 3; i >= 0; i--) {

589 b = (length >> (i * 7)) & 0x7F;

590 if (i != 0)

591 b |= 0x80;

592

593 bytestream2_put_byteu(pb, b);

594 }

595 }

596

597 static CFDataRef videotoolbox_esds_extradata_create(AVCodecContext *avctx)

598 {

599 CFDataRef data;

600 uint8_t *rw_extradata;

601 PutByteContext pb;

602 int full_size = 3 + 5 + 13 + 5 + avctx->extradata_size + 3;

603 // ES_DescrTag data + DecoderConfigDescrTag + data + DecSpecificInfoTag + size + SLConfigDescriptor

604 int config_size = 13 + 5 + avctx->extradata_size;

605 int s;

606

607 if (!(rw_extradata = av_mallocz(full_size + VIDEOTOOLBOX_ESDS_EXTRADATA_PADDING)))

608 return NULL;

609

610 bytestream2_init_writer(&pb, rw_extradata, full_size + VIDEOTOOLBOX_ESDS_EXTRADATA_PADDING);

611 bytestream2_put_byteu(&pb, 0); // version

612 bytestream2_put_ne24(&pb, 0); // flags

613

614 // elementary stream descriptor

615 bytestream2_put_byteu(&pb, 0x03); // ES_DescrTag

616 videotoolbox_write_mp4_descr_length(&pb, full_size);

617 bytestream2_put_ne16(&pb, 0); // esid

618 bytestream2_put_byteu(&pb, 0); // stream priority (0-32)

619

620 // decoder configuration descriptor

621 bytestream2_put_byteu(&pb, 0x04); // DecoderConfigDescrTag

622 videotoolbox_write_mp4_descr_length(&pb, config_size);

623 bytestream2_put_byteu(&pb, 32); // object type indication. 32 = AV_CODEC_ID_MPEG4

624 bytestream2_put_byteu(&pb, 0x11); // stream type

625 bytestream2_put_ne24(&pb, 0); // buffer size

626 bytestream2_put_ne32(&pb, 0); // max bitrate

627 bytestream2_put_ne32(&pb, 0); // avg bitrate

628

629 // decoder specific descriptor

630 bytestream2_put_byteu(&pb, 0x05); ///< DecSpecificInfoTag

631 videotoolbox_write_mp4_descr_length(&pb, avctx->extradata_size);

632

633 bytestream2_put_buffer(&pb, avctx->extradata, avctx->extradata_size);

634

635 // SLConfigDescriptor

636 bytestream2_put_byteu(&pb, 0x06); // SLConfigDescrTag

637 bytestream2_put_byteu(&pb, 0x01); // length

638 bytestream2_put_byteu(&pb, 0x02); //

639

640 s = bytestream2_size_p(&pb);

641

642 data = CFDataCreate(kCFAllocatorDefault, rw_extradata, s);

643

644 av_freep(&rw_extradata);

645 return data;

646 }

647

648 static CMSampleBufferRef videotoolbox_sample_buffer_create(CMFormatDescriptionRef fmt_desc,

649 void *buffer,

650 int size)

651 {

652 OSStatus status;

653 CMBlockBufferRef block_buf;

654 CMSampleBufferRef sample_buf;

655

656 block_buf = NULL;

657 sample_buf = NULL;

658

659 status = CMBlockBufferCreateWithMemoryBlock(kCFAllocatorDefault,// structureAllocator

660 buffer, // memoryBlock

661 size, // blockLength

662 kCFAllocatorNull, // blockAllocator

663 NULL, // customBlockSource

664 0, // offsetToData

665 size, // dataLength

666 0, // flags

667 &block_buf);

668

669 if (!status) {

670 status = CMSampleBufferCreate(kCFAllocatorDefault, // allocator

671 block_buf, // dataBuffer

672 TRUE, // dataReady

673 0, // makeDataReadyCallback

674 0, // makeDataReadyRefcon

675 fmt_desc, // formatDescription

676 1, // numSamples

677 0, // numSampleTimingEntries

678 NULL, // sampleTimingArray

679 0, // numSampleSizeEntries

680 NULL, // sampleSizeArray

681 &sample_buf);

682 }

683

684 if (block_buf)

685 CFRelease(block_buf);

686

687 return sample_buf;

688 }

689

690 static void videotoolbox_decoder_callback(void *opaque,

691 void *sourceFrameRefCon,

692 OSStatus status,

693 VTDecodeInfoFlags flags,

694 CVImageBufferRef image_buffer,

695 CMTime pts,

696 CMTime duration)

697 {

698 VTContext *vtctx = opaque;

699

700 if (vtctx->frame) {

701 CVPixelBufferRelease(vtctx->frame);

702 vtctx->frame = NULL;

703 }

704

705 if (!image_buffer) {

706 av_log(vtctx->logctx, status ? AV_LOG_WARNING : AV_LOG_DEBUG,

707 "vt decoder cb: output image buffer is null: %i\n", status);

708 return;

709 }

710

711 vtctx->frame = CVPixelBufferRetain(image_buffer);

712 }

713

714 static OSStatus videotoolbox_session_decode_frame(AVCodecContext *avctx)

715 {

716 OSStatus status;

717 CMSampleBufferRef sample_buf;

718 AVVideotoolboxContext *videotoolbox = videotoolbox_get_context(avctx);

719 VTContext *vtctx = avctx->internal->hwaccel_priv_data;

720

721 sample_buf = videotoolbox_sample_buffer_create(videotoolbox->cm_fmt_desc,

722 vtctx->bitstream,

723 vtctx->bitstream_size);

724

725 if (!sample_buf)

726 return -1;

727

728 status = VTDecompressionSessionDecodeFrame(videotoolbox->session,

729 sample_buf,

730 0, // decodeFlags

731 NULL, // sourceFrameRefCon

732 0); // infoFlagsOut

733 if (status == noErr)

734 status = VTDecompressionSessionWaitForAsynchronousFrames(videotoolbox->session);

735

736 CFRelease(sample_buf);

737

738 return status;

739 }

740

741 static CMVideoFormatDescriptionRef videotoolbox_format_desc_create(CMVideoCodecType codec_type,

742 CFDictionaryRef decoder_spec,

743 int width,

744 int height)

745 {

746 CMFormatDescriptionRef cm_fmt_desc;

747 OSStatus status;

748

749 status = CMVideoFormatDescriptionCreate(kCFAllocatorDefault,

750 codec_type,

751 width,

752 height,

753 decoder_spec, // Dictionary of extension

754 &cm_fmt_desc);

755

756 if (status)

757 return NULL;

758

759 return cm_fmt_desc;

760 }

761

762 static CFDictionaryRef videotoolbox_buffer_attributes_create(int width,

763 int height,

764 OSType pix_fmt)

765 {

766 CFMutableDictionaryRef buffer_attributes;

767 CFMutableDictionaryRef io_surface_properties;

768 CFNumberRef cv_pix_fmt;

769 CFNumberRef w;

770 CFNumberRef h;

771

772 w = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &width);

773 h = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &height);

774 cv_pix_fmt = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &pix_fmt);

775

776 buffer_attributes = CFDictionaryCreateMutable(kCFAllocatorDefault,

777 4,

778 &kCFTypeDictionaryKeyCallBacks,

779 &kCFTypeDictionaryValueCallBacks);

780 io_surface_properties = CFDictionaryCreateMutable(kCFAllocatorDefault,

781 0,

782 &kCFTypeDictionaryKeyCallBacks,

783 &kCFTypeDictionaryValueCallBacks);

784

785 if (pix_fmt)

786 CFDictionarySetValue(buffer_attributes, kCVPixelBufferPixelFormatTypeKey, cv_pix_fmt);

787 CFDictionarySetValue(buffer_attributes, kCVPixelBufferIOSurfacePropertiesKey, io_surface_properties);

788 CFDictionarySetValue(buffer_attributes, kCVPixelBufferWidthKey, w);

789 CFDictionarySetValue(buffer_attributes, kCVPixelBufferHeightKey, h);

790 #if TARGET_OS_IPHONE

791 CFDictionarySetValue(buffer_attributes, kCVPixelBufferOpenGLESCompatibilityKey, kCFBooleanTrue);

792 #else

793 CFDictionarySetValue(buffer_attributes, kCVPixelBufferIOSurfaceOpenGLTextureCompatibilityKey, kCFBooleanTrue);

794 #endif

795

796 CFRelease(io_surface_properties);

797 CFRelease(cv_pix_fmt);

798 CFRelease(w);

799 CFRelease(h);

800

801 return buffer_attributes;

802 }

803

804 static CFDictionaryRef videotoolbox_decoder_config_create(CMVideoCodecType codec_type,

805 AVCodecContext *avctx)

806 {

807 CFMutableDictionaryRef avc_info;

808 CFDataRef data = NULL;

809

810 CFMutableDictionaryRef config_info = CFDictionaryCreateMutable(kCFAllocatorDefault,

811 0,

812 &kCFTypeDictionaryKeyCallBacks,

813 &kCFTypeDictionaryValueCallBacks);

814

815 CFDictionarySetValue(config_info,

816 codec_type == kCMVideoCodecType_HEVC ?

817 kVTVideoDecoderSpecification_EnableHardwareAcceleratedVideoDecoder :

818 kVTVideoDecoderSpecification_RequireHardwareAcceleratedVideoDecoder,

819 kCFBooleanTrue);

820

821 avc_info = CFDictionaryCreateMutable(kCFAllocatorDefault,

822 1,

823 &kCFTypeDictionaryKeyCallBacks,

824 &kCFTypeDictionaryValueCallBacks);

825

826 switch (codec_type) {

827 case kCMVideoCodecType_MPEG4Video :

828 if (avctx->extradata_size)

829 data = videotoolbox_esds_extradata_create(avctx);

830 if (data)

831 CFDictionarySetValue(avc_info, CFSTR("esds"), data);

832 break;

833 case kCMVideoCodecType_H264 :

834 data = ff_videotoolbox_avcc_extradata_create(avctx);

835 if (data)

836 CFDictionarySetValue(avc_info, CFSTR("avcC"), data);

837 break;

838 case kCMVideoCodecType_HEVC :

839 data = ff_videotoolbox_hvcc_extradata_create(avctx);

840 if (data)

841 CFDictionarySetValue(avc_info, CFSTR("hvcC"), data);

842 break;

843 #if CONFIG_VP9_VIDEOTOOLBOX_HWACCEL

844 case kCMVideoCodecType_VP9 :

845 data = ff_videotoolbox_vpcc_extradata_create(avctx);

846 if (data)

847 CFDictionarySetValue(avc_info, CFSTR("vpcC"), data);

848 break;

849 #endif

850 default:

851 break;

852 }

853

854 CFDictionarySetValue(config_info,

855 kCMFormatDescriptionExtension_SampleDescriptionExtensionAtoms,

856 avc_info);

857

858 if (data)

859 CFRelease(data);

860

861 CFRelease(avc_info);

862 return config_info;

863 }

864

865 static int videotoolbox_start(AVCodecContext *avctx)

866 {

867 AVVideotoolboxContext *videotoolbox = videotoolbox_get_context(avctx);

868 OSStatus status;

869 VTDecompressionOutputCallbackRecord decoder_cb;

870 CFDictionaryRef decoder_spec;

871 CFDictionaryRef buf_attr;

872

873 if (!videotoolbox) {

874 av_log(avctx, AV_LOG_ERROR, "hwaccel context is not set\n");

875 return -1;

876 }

877

878 switch( avctx->codec_id ) {

879 case AV_CODEC_ID_H263 :

880 videotoolbox->cm_codec_type = kCMVideoCodecType_H263;

881 break;

882 case AV_CODEC_ID_H264 :

883 videotoolbox->cm_codec_type = kCMVideoCodecType_H264;

884 break;

885 case AV_CODEC_ID_HEVC :

886 videotoolbox->cm_codec_type = kCMVideoCodecType_HEVC;

887 break;

888 case AV_CODEC_ID_MPEG1VIDEO :

889 videotoolbox->cm_codec_type = kCMVideoCodecType_MPEG1Video;

890 break;

891 case AV_CODEC_ID_MPEG2VIDEO :

892 videotoolbox->cm_codec_type = kCMVideoCodecType_MPEG2Video;

893 break;

894 case AV_CODEC_ID_MPEG4 :

895 videotoolbox->cm_codec_type = kCMVideoCodecType_MPEG4Video;

896 break;

897 case AV_CODEC_ID_PRORES :

898 switch (avctx->codec_tag) {

899 default:

900 av_log(avctx, AV_LOG_WARNING, "Unknown prores profile %d\n", avctx->codec_tag);

901 // fall-through

902 case MKTAG('a','p','c','o'): // kCMVideoCodecType_AppleProRes422Proxy

903 case MKTAG('a','p','c','s'): // kCMVideoCodecType_AppleProRes422LT

904 case MKTAG('a','p','c','n'): // kCMVideoCodecType_AppleProRes422

905 case MKTAG('a','p','c','h'): // kCMVideoCodecType_AppleProRes422HQ

906 case MKTAG('a','p','4','h'): // kCMVideoCodecType_AppleProRes4444

907 case MKTAG('a','p','4','x'): // kCMVideoCodecType_AppleProRes4444XQ

908 videotoolbox->cm_codec_type = av_bswap32(avctx->codec_tag);

909 break;

910 }

911 break;

912 case AV_CODEC_ID_VP9 :

913 videotoolbox->cm_codec_type = kCMVideoCodecType_VP9;

914 break;

915 default :

916 break;

917 }

918

919 #if defined(MAC_OS_X_VERSION_10_9) && !TARGET_OS_IPHONE && (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_9) && AV_HAS_BUILTIN(__builtin_available)

920 if (avctx->codec_id == AV_CODEC_ID_PRORES) {

921 if (__builtin_available(macOS 10.9, *)) {

922 VTRegisterProfessionalVideoWorkflowVideoDecoders();

923 }

924 }

925 #endif

926

927 #if defined(MAC_OS_VERSION_11_0) && !TARGET_OS_IPHONE && (MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_VERSION_11_0) && AV_HAS_BUILTIN(__builtin_available)

928 if (__builtin_available(macOS 11.0, *)) {

929 VTRegisterSupplementalVideoDecoderIfAvailable(videotoolbox->cm_codec_type);

930 }

931 #endif

932

933 decoder_spec = videotoolbox_decoder_config_create(videotoolbox->cm_codec_type, avctx);

934

935 if (!decoder_spec) {

936 av_log(avctx, AV_LOG_ERROR, "decoder specification creation failed\n");

937 return -1;

938 }

939

940 videotoolbox->cm_fmt_desc = videotoolbox_format_desc_create(videotoolbox->cm_codec_type,

941 decoder_spec,

942 avctx->width,

943 avctx->height);

944 if (!videotoolbox->cm_fmt_desc) {

945 if (decoder_spec)

946 CFRelease(decoder_spec);

947

948 av_log(avctx, AV_LOG_ERROR, "format description creation failed\n");

949 return -1;

950 }

951

952 buf_attr = videotoolbox_buffer_attributes_create(avctx->width,

953 avctx->height,

954 videotoolbox->cv_pix_fmt_type);

955

956 decoder_cb.decompressionOutputCallback = videotoolbox_decoder_callback;

957 decoder_cb.decompressionOutputRefCon = avctx->internal->hwaccel_priv_data;

958

959 status = VTDecompressionSessionCreate(NULL, // allocator

960 videotoolbox->cm_fmt_desc, // videoFormatDescription

961 decoder_spec, // videoDecoderSpecification

962 buf_attr, // destinationImageBufferAttributes

963 &decoder_cb, // outputCallback

964 &videotoolbox->session); // decompressionSessionOut

965

966 if (decoder_spec)

967 CFRelease(decoder_spec);

968 if (buf_attr)

969 CFRelease(buf_attr);

970

971 switch (status) {

972 case kVTVideoDecoderNotAvailableNowErr:

973 av_log(avctx, AV_LOG_VERBOSE, "VideoToolbox session not available.\n");

974 return AVERROR(ENOSYS);

975 case kVTVideoDecoderUnsupportedDataFormatErr:

976 av_log(avctx, AV_LOG_VERBOSE, "VideoToolbox does not support this format.\n");

977 return AVERROR(ENOSYS);

978 case kVTCouldNotFindVideoDecoderErr:

979 av_log(avctx, AV_LOG_VERBOSE, "VideoToolbox decoder for this format not found.\n");

980 return AVERROR(ENOSYS);

981 case kVTVideoDecoderMalfunctionErr:

982 av_log(avctx, AV_LOG_VERBOSE, "VideoToolbox malfunction.\n");

983 return AVERROR(EINVAL);

984 case kVTVideoDecoderBadDataErr:

985 av_log(avctx, AV_LOG_VERBOSE, "VideoToolbox reported invalid data.\n");

986 return AVERROR_INVALIDDATA;

987 case 0:

988 return 0;

989 default:

990 av_log(avctx, AV_LOG_VERBOSE, "Unknown VideoToolbox session creation error %d\n", (int)status);

991 return AVERROR_UNKNOWN;

992 }

993 }

994

995 static const char *videotoolbox_error_string(OSStatus status)

996 {

997 switch (status) {

998 case kVTVideoDecoderBadDataErr:

999 return "bad data";

1000 case kVTVideoDecoderMalfunctionErr:

1001 return "decoder malfunction";

1002 case kVTInvalidSessionErr:

1003 return "invalid session";

1004 }

1005 return "unknown";

1006 }

1007

1008 int ff_videotoolbox_common_end_frame(AVCodecContext *avctx, AVFrame *frame)

1009 {

1010 OSStatus status;

1011 AVVideotoolboxContext *videotoolbox = videotoolbox_get_context(avctx);

1012 VTContext *vtctx = avctx->internal->hwaccel_priv_data;

1013

1014 if (vtctx->reconfig_needed == true) {

1015 vtctx->reconfig_needed = false;

1016 av_log(avctx, AV_LOG_VERBOSE, "VideoToolbox decoder needs reconfig, restarting..\n");

1017 videotoolbox_stop(avctx);

1018 if (videotoolbox_start(avctx) != 0) {

1019 return AVERROR_EXTERNAL;

1020 }

1021 }

1022

1023 if (!videotoolbox->session || !vtctx->bitstream || !vtctx->bitstream_size)

1024 return AVERROR_INVALIDDATA;

1025

1026 status = videotoolbox_session_decode_frame(avctx);

1027 if (status != noErr) {

1028 if (status == kVTVideoDecoderMalfunctionErr || status == kVTInvalidSessionErr)

1029 vtctx->reconfig_needed = true;

1030 av_log(avctx, AV_LOG_ERROR, "Failed to decode frame (%s, %d)\n", videotoolbox_error_string(status), (int)status);

1031 return AVERROR_UNKNOWN;

1032 }

1033

1034 if (!vtctx->frame) {

1035 vtctx->reconfig_needed = true;

1036 return AVERROR_UNKNOWN;

1037 }

1038

1039 return videotoolbox_buffer_create(avctx, frame);

1040 }

1041

1042 static int videotoolbox_h264_end_frame(AVCodecContext *avctx)

1043 {

1044 H264Context *h = avctx->priv_data;

1045 AVFrame *frame = h->cur_pic_ptr->f;

1046 VTContext *vtctx = avctx->internal->hwaccel_priv_data;

1047 int ret = ff_videotoolbox_common_end_frame(avctx, frame);

1048 vtctx->bitstream_size = 0;

1049 return ret;

1050 }

1051

1052 static int videotoolbox_hevc_start_frame(AVCodecContext *avctx,

1053 const uint8_t *buffer,

1054 uint32_t size)

1055 {

1056 HEVCContext *h = avctx->priv_data;

1057 AVFrame *frame = h->cur_frame->f;

1058

1059 frame->crop_right = 0;

1060 frame->crop_left = 0;

1061 frame->crop_top = 0;

1062 frame->crop_bottom = 0;

1063

1064 return 0;

1065 }

1066

1067 static int videotoolbox_hevc_decode_slice(AVCodecContext *avctx,

1068 const uint8_t *buffer,

1069 uint32_t size)

1070 {

1071 return videotoolbox_common_decode_slice(avctx, buffer, size);

1072 }

1073

1074

1075 static int videotoolbox_hevc_decode_params(AVCodecContext *avctx,

1076 int type,

1077 const uint8_t *buffer,

1078 uint32_t size)

1079 {

1080 return videotoolbox_common_decode_slice(avctx, buffer, size);

1081 }

1082

1083 static int videotoolbox_hevc_end_frame(AVCodecContext *avctx)

1084 {

1085 HEVCContext *h = avctx->priv_data;

1086 AVFrame *frame = h->cur_frame->f;

1087 VTContext *vtctx = avctx->internal->hwaccel_priv_data;

1088 int ret;

1089

1090 ret = ff_videotoolbox_common_end_frame(avctx, frame);

1091 vtctx->bitstream_size = 0;

1092 return ret;

1093 }

1094

1095 static int videotoolbox_mpeg_start_frame(AVCodecContext *avctx,

1096 const uint8_t *buffer,

1097 uint32_t size)

1098 {

1099 VTContext *vtctx = avctx->internal->hwaccel_priv_data;

1100

1101 return ff_videotoolbox_buffer_copy(vtctx, buffer, size);

1102 }

1103

1104 static int videotoolbox_mpeg_decode_slice(AVCodecContext *avctx,

1105 const uint8_t *buffer,

1106 uint32_t size)

1107 {

1108 return 0;

1109 }

1110

1111 static int videotoolbox_mpeg_end_frame(AVCodecContext *avctx)

1112 {

1113 MpegEncContext *s = avctx->priv_data;

1114 AVFrame *frame = s->cur_pic.ptr->f;

1115

1116 return ff_videotoolbox_common_end_frame(avctx, frame);

1117 }

1118

1119 static int videotoolbox_prores_start_frame(AVCodecContext *avctx,

1120 const uint8_t *buffer,

1121 uint32_t size)

1122 {

1123 return 0;

1124 }

1125

1126 static int videotoolbox_prores_decode_slice(AVCodecContext *avctx,

1127 const uint8_t *buffer,

1128 uint32_t size)

1129 {

1130 VTContext *vtctx = avctx->internal->hwaccel_priv_data;

1131

1132 return ff_videotoolbox_buffer_copy(vtctx, buffer, size);

1133 }

1134

1135 static int videotoolbox_prores_end_frame(AVCodecContext *avctx)

1136 {

1137 ProresContext *ctx = avctx->priv_data;

1138 AVFrame *frame = ctx->frame;

1139

1140 return ff_videotoolbox_common_end_frame(avctx, frame);

1141 }

1142

1143 static enum AVPixelFormat videotoolbox_best_pixel_format(AVCodecContext *avctx) {

1144 int depth;

1145 const AVPixFmtDescriptor *descriptor = av_pix_fmt_desc_get(avctx->sw_pix_fmt);

1146 if (!descriptor)

1147 return AV_PIX_FMT_NV12; // same as av_videotoolbox_alloc_context()

1148

1149

1150 if (descriptor->flags & AV_PIX_FMT_FLAG_ALPHA)

1151 return AV_PIX_FMT_AYUV64;

1152

1153 depth = descriptor->comp[0].depth;

1154

1155 #if HAVE_KCVPIXELFORMATTYPE_444YPCBCR16BIPLANARVIDEORANGE

1156 if (depth > 10)

1157 return descriptor->log2_chroma_w == 0 ? AV_PIX_FMT_P416 : AV_PIX_FMT_P216;

1158 #endif

1159

1160 #if HAVE_KCVPIXELFORMATTYPE_444YPCBCR10BIPLANARVIDEORANGE

1161 if (descriptor->log2_chroma_w == 0) {

1162 #if HAVE_KCVPIXELFORMATTYPE_444YPCBCR8BIPLANARVIDEORANGE

1163 if (depth <= 8)

1164 return AV_PIX_FMT_NV24;

1165 #endif

1166 return AV_PIX_FMT_P410;

1167 }

1168 #endif

1169 #if HAVE_KCVPIXELFORMATTYPE_422YPCBCR10BIPLANARVIDEORANGE

1170 if (descriptor->log2_chroma_h == 0) {

1171 #if HAVE_KCVPIXELFORMATTYPE_422YPCBCR8BIPLANARVIDEORANGE

1172 if (depth <= 8)

1173 return AV_PIX_FMT_NV16;

1174 #endif

1175 return AV_PIX_FMT_P210;

1176 }

1177 #endif

1178 #if HAVE_KCVPIXELFORMATTYPE_420YPCBCR10BIPLANARVIDEORANGE

1179 if (depth > 8) {

1180 return AV_PIX_FMT_P010;

1181 }

1182 #endif

1183

1184 return AV_PIX_FMT_NV12;

1185 }

1186

1187 static AVVideotoolboxContext *videotoolbox_alloc_context_with_pix_fmt(enum AVPixelFormat pix_fmt,

1188 bool full_range)

1189 {

1190 AVVideotoolboxContext *ret = av_mallocz(sizeof(*ret));

1191

1192 if (ret) {

1193 OSType cv_pix_fmt_type = av_map_videotoolbox_format_from_pixfmt2(pix_fmt, full_range);

1194 if (cv_pix_fmt_type == 0) {

1195 cv_pix_fmt_type = kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange;

1196 }

1197 ret->cv_pix_fmt_type = cv_pix_fmt_type;

1198 }

1199

1200 return ret;

1201 }

1202

1203 int ff_videotoolbox_common_init(AVCodecContext *avctx)

1204 {

1205 VTContext *vtctx = avctx->internal->hwaccel_priv_data;

1206 AVHWFramesContext *hw_frames;

1207 AVVTFramesContext *hw_ctx;

1208 int err;

1209 bool full_range;

1210

1211 vtctx->logctx = avctx;

1212

1213 if (!avctx->hw_frames_ctx && !avctx->hw_device_ctx &&

1214 avctx->hwaccel_context)

1215 return videotoolbox_start(avctx);

1216

1217 if (!avctx->hw_frames_ctx && !avctx->hw_device_ctx) {

1218 av_log(avctx, AV_LOG_ERROR,

1219 "Either hw_frames_ctx or hw_device_ctx must be set.\n");

1220 return AVERROR(EINVAL);

1221 }

1222

1223 vtctx->vt_ctx = videotoolbox_alloc_context_with_pix_fmt(AV_PIX_FMT_NONE, false);

1224 if (!vtctx->vt_ctx) {

1225 err = AVERROR(ENOMEM);

1226 goto fail;

1227 }

1228

1229 if (avctx->hw_frames_ctx) {

1230 hw_frames = (AVHWFramesContext*)avctx->hw_frames_ctx->data;

1231 } else {

1232 avctx->hw_frames_ctx = av_hwframe_ctx_alloc(avctx->hw_device_ctx);

1233 if (!avctx->hw_frames_ctx) {

1234 err = AVERROR(ENOMEM);

1235 goto fail;

1236 }

1237

1238 hw_frames = (AVHWFramesContext*)avctx->hw_frames_ctx->data;

1239 hw_frames->format = AV_PIX_FMT_VIDEOTOOLBOX;

1240 hw_frames->sw_format = videotoolbox_best_pixel_format(avctx);

1241 hw_frames->width = avctx->width;

1242 hw_frames->height = avctx->height;

1243 hw_ctx = hw_frames->hwctx;

1244 hw_ctx->color_range = avctx->color_range;

1245

1246 err = av_hwframe_ctx_init(avctx->hw_frames_ctx);

1247 if (err < 0) {

1248 av_buffer_unref(&avctx->hw_frames_ctx);

1249 goto fail;

1250 }

1251 }

1252

1253 vtctx->cached_hw_frames_ctx = av_buffer_ref(avctx->hw_frames_ctx);

1254 if (!vtctx->cached_hw_frames_ctx) {

1255 err = AVERROR(ENOMEM);

1256 goto fail;

1257 }

1258

1259 full_range = avctx->color_range == AVCOL_RANGE_JPEG;

1260 vtctx->vt_ctx->cv_pix_fmt_type =

1261 av_map_videotoolbox_format_from_pixfmt2(hw_frames->sw_format, full_range);

1262 if (!vtctx->vt_ctx->cv_pix_fmt_type) {

1263 const AVPixFmtDescriptor *attempted_format =

1264 av_pix_fmt_desc_get(hw_frames->sw_format);

1265 av_log(avctx, AV_LOG_ERROR,

1266 "Failed to map underlying FFmpeg pixel format %s (%s range) to "

1267 "a VideoToolbox format!\n",

1268 attempted_format ? attempted_format->name : "<unknown>",

1269 av_color_range_name(avctx->color_range));

1270 err = AVERROR(EINVAL);

1271 goto fail;

1272 }

1273

1274 err = videotoolbox_start(avctx);

1275 if (err < 0)

1276 goto fail;

1277

1278 return 0;

1279

1280 fail:

1281 ff_videotoolbox_uninit(avctx);

1282 return err;

1283 }

1284

1285 int ff_videotoolbox_frame_params(AVCodecContext *avctx,

1286 AVBufferRef *hw_frames_ctx)

1287 {

1288 AVHWFramesContext *frames_ctx = (AVHWFramesContext*)hw_frames_ctx->data;

1289

1290 frames_ctx->format = AV_PIX_FMT_VIDEOTOOLBOX;

1291 frames_ctx->width = avctx->coded_width;

1292 frames_ctx->height = avctx->coded_height;

1293 frames_ctx->sw_format = videotoolbox_best_pixel_format(avctx);

1294

1295 return 0;

1296 }

1297

1298 const FFHWAccel ff_h263_videotoolbox_hwaccel = {

1299 .p.name = "h263_videotoolbox",

1300 .p.type = AVMEDIA_TYPE_VIDEO,

1301 .p.id = AV_CODEC_ID_H263,

1302 .p.pix_fmt = AV_PIX_FMT_VIDEOTOOLBOX,

1303 .alloc_frame = ff_videotoolbox_alloc_frame,

1304 .start_frame = videotoolbox_mpeg_start_frame,

1305 .decode_slice = videotoolbox_mpeg_decode_slice,

1306 .end_frame = videotoolbox_mpeg_end_frame,

1307 .frame_params = ff_videotoolbox_frame_params,

1308 .init = ff_videotoolbox_common_init,

1309 .uninit = ff_videotoolbox_uninit,

1310 .priv_data_size = sizeof(VTContext),

1311 };

1312

1313 const FFHWAccel ff_hevc_videotoolbox_hwaccel = {

1314 .p.name = "hevc_videotoolbox",

1315 .p.type = AVMEDIA_TYPE_VIDEO,

1316 .p.id = AV_CODEC_ID_HEVC,

1317 .p.pix_fmt = AV_PIX_FMT_VIDEOTOOLBOX,

1318 .alloc_frame = ff_videotoolbox_alloc_frame,

1319 .start_frame = videotoolbox_hevc_start_frame,

1320 .decode_slice = videotoolbox_hevc_decode_slice,

1321 .decode_params = videotoolbox_hevc_decode_params,

1322 .end_frame = videotoolbox_hevc_end_frame,

1323 .frame_params = ff_videotoolbox_frame_params,

1324 .init = ff_videotoolbox_common_init,

1325 .uninit = ff_videotoolbox_uninit,

1326 .priv_data_size = sizeof(VTContext),

1327 };

1328

1329 const FFHWAccel ff_h264_videotoolbox_hwaccel = {

1330 .p.name = "h264_videotoolbox",

1331 .p.type = AVMEDIA_TYPE_VIDEO,

1332 .p.id = AV_CODEC_ID_H264,

1333 .p.pix_fmt = AV_PIX_FMT_VIDEOTOOLBOX,

1334 .alloc_frame = ff_videotoolbox_alloc_frame,

1335 .start_frame = ff_videotoolbox_h264_start_frame,

1336 .decode_slice = ff_videotoolbox_h264_decode_slice,

1337 .decode_params = videotoolbox_h264_decode_params,

1338 .end_frame = videotoolbox_h264_end_frame,

1339 .frame_params = ff_videotoolbox_frame_params,

1340 .init = ff_videotoolbox_common_init,

1341 .uninit = ff_videotoolbox_uninit,

1342 .priv_data_size = sizeof(VTContext),

1343 };

1344

1345 const FFHWAccel ff_mpeg1_videotoolbox_hwaccel = {

1346 .p.name = "mpeg1_videotoolbox",

1347 .p.type = AVMEDIA_TYPE_VIDEO,

1348 .p.id = AV_CODEC_ID_MPEG1VIDEO,

1349 .p.pix_fmt = AV_PIX_FMT_VIDEOTOOLBOX,

1350 .alloc_frame = ff_videotoolbox_alloc_frame,

1351 .start_frame = videotoolbox_mpeg_start_frame,

1352 .decode_slice = videotoolbox_mpeg_decode_slice,

1353 .end_frame = videotoolbox_mpeg_end_frame,

1354 .frame_params = ff_videotoolbox_frame_params,

1355 .init = ff_videotoolbox_common_init,

1356 .uninit = ff_videotoolbox_uninit,

1357 .priv_data_size = sizeof(VTContext),

1358 };

1359

1360 const FFHWAccel ff_mpeg2_videotoolbox_hwaccel = {

1361 .p.name = "mpeg2_videotoolbox",

1362 .p.type = AVMEDIA_TYPE_VIDEO,

1363 .p.id = AV_CODEC_ID_MPEG2VIDEO,

1364 .p.pix_fmt = AV_PIX_FMT_VIDEOTOOLBOX,

1365 .alloc_frame = ff_videotoolbox_alloc_frame,

1366 .start_frame = videotoolbox_mpeg_start_frame,

1367 .decode_slice = videotoolbox_mpeg_decode_slice,

1368 .end_frame = videotoolbox_mpeg_end_frame,

1369 .frame_params = ff_videotoolbox_frame_params,

1370 .init = ff_videotoolbox_common_init,

1371 .uninit = ff_videotoolbox_uninit,

1372 .priv_data_size = sizeof(VTContext),

1373 };

1374

1375 const FFHWAccel ff_mpeg4_videotoolbox_hwaccel = {

1376 .p.name = "mpeg4_videotoolbox",

1377 .p.type = AVMEDIA_TYPE_VIDEO,

1378 .p.id = AV_CODEC_ID_MPEG4,

1379 .p.pix_fmt = AV_PIX_FMT_VIDEOTOOLBOX,

1380 .alloc_frame = ff_videotoolbox_alloc_frame,

1381 .start_frame = videotoolbox_mpeg_start_frame,

1382 .decode_slice = videotoolbox_mpeg_decode_slice,

1383 .end_frame = videotoolbox_mpeg_end_frame,

1384 .frame_params = ff_videotoolbox_frame_params,

1385 .init = ff_videotoolbox_common_init,

1386 .uninit = ff_videotoolbox_uninit,

1387 .priv_data_size = sizeof(VTContext),

1388 };

1389

1390 const FFHWAccel ff_prores_videotoolbox_hwaccel = {

1391 .p.name = "prores_videotoolbox",

1392 .p.type = AVMEDIA_TYPE_VIDEO,

1393 .p.id = AV_CODEC_ID_PRORES,

1394 .p.pix_fmt = AV_PIX_FMT_VIDEOTOOLBOX,

1395 .alloc_frame = ff_videotoolbox_alloc_frame,

1396 .start_frame = videotoolbox_prores_start_frame,

1397 .decode_slice = videotoolbox_prores_decode_slice,

1398 .end_frame = videotoolbox_prores_end_frame,

1399 .frame_params = ff_videotoolbox_frame_params,

1400 .init = ff_videotoolbox_common_init,

1401 .uninit = ff_videotoolbox_uninit,

1402 .priv_data_size = sizeof(VTContext),

1403 };

1404

1405 #endif /* CONFIG_VIDEOTOOLBOX */

videotoolbox_buffer_release

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

Definition: videotoolbox.c:66

AVVideotoolboxContext::cm_codec_type

int cm_codec_type

CoreMedia codec type that Videotoolbox will use to create the decompression session.

Definition: videotoolbox.h:78

AVCodecContext::hwaccel_context

void * hwaccel_context

Legacy hardware accelerator context.

Definition: avcodec.h:1461

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

APPEND_PS

#define APPEND_PS(T, t)

AVPixelFormat

Pixel format.

Definition: pixfmt.h:71

ff_videotoolbox_common_end_frame

int ff_videotoolbox_common_end_frame(AVCodecContext *avctx, AVFrame *frame)

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

av_pix_fmt_desc_get

const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)

Definition: pixdesc.c:2965

AVBufferRef::data

uint8_t * data

The data buffer.

Definition: buffer.h:90

ff_videotoolbox_uninit

int ff_videotoolbox_uninit(AVCodecContext *avctx)

AVHWFramesContext::format

enum AVPixelFormat format

The pixel format identifying the underlying HW surface type.

Definition: hwcontext.h:197

FFHWAccel::p

AVHWAccel p

The public AVHWAccel.

Definition: hwaccel_internal.h:38

AV_CODEC_ID_MPEG4

@ AV_CODEC_ID_MPEG4

Definition: codec_id.h:64

FrameDecodeData

This struct stores per-frame lavc-internal data and is attached to it via private_ref.

Definition: decode.h:33

av_hwframe_ctx_init

int av_hwframe_ctx_init(AVBufferRef *ref)

Finalize the context before use.

Definition: hwcontext.c:322

AVFrame

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

Definition: frame.h:389

tmp

static uint8_t tmp[11]

Definition: aes_ctr.c:28

pixdesc.h

uint8_t w

Definition: llviddspenc.c:38

AVCOL_RANGE_JPEG

@ AVCOL_RANGE_JPEG

Full range content.

Definition: pixfmt.h:686

av_hwframe_ctx_alloc

AVBufferRef * av_hwframe_ctx_alloc(AVBufferRef *device_ref_in)

Allocate an AVHWFramesContext tied to a given device context.

Definition: hwcontext.c:248

internal.h

AVComponentDescriptor::depth

int depth

Number of bits in the component.

Definition: pixdesc.h:57

AVPixFmtDescriptor::name

const char * name

Definition: pixdesc.h:70

#define b

Definition: input.c:41

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

ProresContext

Definition: proresdec.h:43

AV_LOG_VERBOSE

#define AV_LOG_VERBOSE

Detailed information.

Definition: log.h:196

bytestream2_size_p

static av_always_inline int bytestream2_size_p(PutByteContext *p)

Definition: bytestream.h:207

AV_W8

#define AV_W8(p, v)

Definition: videotoolbox.c:156

PTLCommon::profile_space

uint8_t profile_space

Definition: ps.h:128

COUNT_SIZE_PS

#define COUNT_SIZE_PS(T, t)

mpegvideo.h

av_buffer_ref

AVBufferRef * av_buffer_ref(const AVBufferRef *buf)

Create a new reference to an AVBuffer.

Definition: buffer.c:103

ff_mpeg2_videotoolbox_hwaccel

const struct FFHWAccel ff_mpeg2_videotoolbox_hwaccel

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

codec_type

enum AVMediaType codec_type

Definition: rtp.c:37

AVVideotoolboxContext

This struct holds all the information that needs to be passed between the caller and libavcodec for i...

Definition: videotoolbox.h:57

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:30

PTLCommon::profile_compatibility_flag

uint8_t profile_compatibility_flag[32]

Definition: ps.h:131

escape_ps

static int escape_ps(uint8_t *dst, const uint8_t *src, int src_size)

Definition: videotoolbox.c:158

#define S(s, c, i)

Definition: flacdsp_template.c:46

PTLCommon::progressive_source_flag

uint8_t progressive_source_flag

Definition: ps.h:132

ff_hevc_videotoolbox_hwaccel

const struct FFHWAccel ff_hevc_videotoolbox_hwaccel

FFHWAccel

Definition: hwaccel_internal.h:34

PTLCommon::interlaced_source_flag

uint8_t interlaced_source_flag

Definition: ps.h:133

ff_videotoolbox_avcc_extradata_create

CFDataRef ff_videotoolbox_avcc_extradata_create(AVCodecContext *avctx)

Definition: videotoolbox.c:187

fail

#define fail()

Definition: checkasm.h:188

ff_h263_videotoolbox_hwaccel

const struct FFHWAccel ff_h263_videotoolbox_hwaccel

proresdec.h

type

it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type

Definition: writing_filters.txt:86

pts

static int64_t pts

Definition: transcode_aac.c:644

AVCodecContext::coded_height

int coded_height

Definition: avcodec.h:639

VTContext::allocated_size

int allocated_size

Definition: vt_internal.h:33

ff_videotoolbox_common_init

int ff_videotoolbox_common_init(AVCodecContext *avctx)

PTLCommon::frame_only_constraint_flag

uint8_t frame_only_constraint_flag

Definition: ps.h:135

videotoolbox.h

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

VTContext::bitstream

uint8_t * bitstream

Definition: vt_internal.h:27

ff_videotoolbox_h264_start_frame

int ff_videotoolbox_h264_start_frame(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)

Definition: videotoolbox.c:389

kVTVideoDecoderSpecification_EnableHardwareAcceleratedVideoDecoder

#define kVTVideoDecoderSpecification_EnableHardwareAcceleratedVideoDecoder

Definition: videotoolbox.c:48

AVHWFramesContext::height

int height

Definition: hwcontext.h:217

duration

int64_t duration

Definition: movenc.c:65

bytestream2_init_writer

static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)

Definition: bytestream.h:147

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:530

bytestream2_put_ne24

#define bytestream2_put_ne24

Definition: bytestream.h:128

full_range

bool full_range

Definition: hwcontext_videotoolbox.c:46

av_fast_realloc

void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)

Reallocate the given buffer if it is not large enough, otherwise do nothing.

Definition: mem.c:497

vt_internal.h

PTLCommon

Definition: ps.h:127

#define s(width, name)

Definition: cbs_vp9.c:198

kCMVideoCodecType_HEVC

@ kCMVideoCodecType_HEVC

Definition: videotoolbox.c:52

VTHWFrame

Definition: videotoolbox.c:61

pix_fmt

static enum AVPixelFormat pix_fmt

Definition: demux_decode.c:41

bytestream2_put_buffer

static av_always_inline unsigned int bytestream2_put_buffer(PutByteContext *p, const uint8_t *src, unsigned int size)

Definition: bytestream.h:286

ff_mpeg1_videotoolbox_hwaccel

const struct FFHWAccel ff_mpeg1_videotoolbox_hwaccel

AV_CODEC_ID_VP9

@ AV_CODEC_ID_VP9

Definition: codec_id.h:220

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:40

ff_videotoolbox_vpcc_extradata_create

CFDataRef ff_videotoolbox_vpcc_extradata_create(AVCodecContext *avctx)

Definition: videotoolbox_vp9.c:65

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:201

AV_PIX_FMT_FLAG_ALPHA

#define AV_PIX_FMT_FLAG_ALPHA

The pixel format has an alpha channel.

Definition: pixdesc.h:147

ctx

AVFormatContext * ctx

Definition: movenc.c:49

decode.h

PTLCommon::non_packed_constraint_flag

uint8_t non_packed_constraint_flag

Definition: ps.h:134

AVPixFmtDescriptor::log2_chroma_w

uint8_t log2_chroma_w

Amount to shift the luma width right to find the chroma width.

Definition: pixdesc.h:80

PTLCommon::profile_idc

uint8_t profile_idc

Definition: ps.h:130

AVVTFramesContext

Definition: hwcontext_videotoolbox.h:45

AV_CODEC_ID_H264

@ AV_CODEC_ID_H264

Definition: codec_id.h:79

PTLCommon::tier_flag

uint8_t tier_flag

Definition: ps.h:129

AVCodecContext::codec_id

enum AVCodecID codec_id

Definition: avcodec.h:461

if(ret)

Definition: filter_design.txt:179

VTContext::bitstream_size

int bitstream_size

Definition: vt_internal.h:30

av_color_range_name

const char * av_color_range_name(enum AVColorRange range)

Definition: pixdesc.c:3281

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

AVCodecContext::color_range

enum AVColorRange color_range

MPEG vs JPEG YUV range.

Definition: avcodec.h:701

av_buffer_unref

void av_buffer_unref(AVBufferRef **buf)

Free a given reference and automatically free the buffer if there are no more references to it.

Definition: buffer.c:139

hwaccel_internal.h

AV_WB16

#define AV_WB16(p, v)

Definition: intreadwrite.h:401

AVVTFramesContext::color_range

enum AVColorRange color_range

Definition: hwcontext_videotoolbox.h:46

AVHWFramesContext::device_ref

AVBufferRef * device_ref

A reference to the parent AVHWDeviceContext.

Definition: hwcontext.h:126

AVCodecContext::internal

struct AVCodecInternal * internal

Private context used for internal data.

Definition: avcodec.h:486

#define V

Definition: avdct.c:31

AV_PIX_FMT_P410

#define AV_PIX_FMT_P410

Definition: pixfmt.h:540

AVVideotoolboxContext::session

VTDecompressionSessionRef session

Videotoolbox decompression session object.

Definition: videotoolbox.h:61

vps

static int FUNC() vps(CodedBitstreamContext *ctx, RWContext *rw, H265RawVPS *current)

Definition: cbs_h265_syntax_template.c:423

AVPixFmtDescriptor::flags

uint64_t flags

Combination of AV_PIX_FMT_FLAG_...

Definition: pixdesc.h:94

ff_videotoolbox_frame_params

int ff_videotoolbox_frame_params(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx)

ff_videotoolbox_h264_decode_slice

int ff_videotoolbox_h264_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)

Definition: videotoolbox.c:449

AV_CODEC_ID_MPEG1VIDEO

@ AV_CODEC_ID_MPEG1VIDEO

Definition: codec_id.h:53

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

videotoolbox_common_decode_slice

static int videotoolbox_common_decode_slice(AVCodecContext *avctx, const uint8_t *buffer, uint32_t size)

Definition: videotoolbox.c:426

VTHWFrame::pixbuf

CVPixelBufferRef pixbuf

Definition: videotoolbox.c:62

AV_WB32

#define AV_WB32(p, v)

Definition: intreadwrite.h:415

PutByteContext

Definition: bytestream.h:37

hwcontext_videotoolbox.h

ff_prores_videotoolbox_hwaccel

const struct FFHWAccel ff_prores_videotoolbox_hwaccel

ff_videotoolbox_hvcc_extradata_create

CFDataRef ff_videotoolbox_hvcc_extradata_create(AVCodecContext *avctx)

Definition: videotoolbox.c:232

hevcdec.h

height

#define height

Definition: dsp.h:85

AV_WN32

#define AV_WN32(p, v)

Definition: intreadwrite.h:372

FrameDecodeData::post_process

int(* post_process)(void *logctx, AVFrame *frame)

The callback to perform some delayed processing on the frame right before it is returned to the calle...

Definition: decode.h:44

AVCodecInternal::hwaccel_priv_data

void * hwaccel_priv_data

hwaccel-specific private data

Definition: internal.h:130

#define P

kCMVideoCodecType_VP9

@ kCMVideoCodecType_VP9

Definition: videotoolbox.c:56

dst

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

Definition: dsp.h:83

av_bswap32

#define av_bswap32

Definition: bswap.h:47

AV_CODEC_ID_H263

@ AV_CODEC_ID_H263

Definition: codec_id.h:56

size

int size

Definition: twinvq_data.h:10344

VUI

Definition: ps.h:98

AV_PIX_FMT_AYUV64

#define AV_PIX_FMT_AYUV64

Definition: pixfmt.h:527

AVVideotoolboxContext::cm_fmt_desc

CMVideoFormatDescriptionRef cm_fmt_desc

CoreMedia Format Description that Videotoolbox will use to create the decompression session.

Definition: videotoolbox.h:73

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

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

VTContext

Definition: vt_internal.h:25

AVHWAccel::name

const char * name

Name of the hardware accelerated codec.

Definition: avcodec.h:2105

kVTVideoDecoderSpecification_RequireHardwareAcceleratedVideoDecoder

#define kVTVideoDecoderSpecification_RequireHardwareAcceleratedVideoDecoder

Definition: videotoolbox.c:45

AV_PIX_FMT_VIDEOTOOLBOX

@ AV_PIX_FMT_VIDEOTOOLBOX

hardware decoding through Videotoolbox

Definition: pixfmt.h:305

h264dec.h

H264Context

H264Context.

Definition: h264dec.h:340

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

Definition: cbs_h2645.c:256

AVCodecContext::extradata

uint8_t * extradata

some codecs need / can use extradata like Huffman tables.

Definition: avcodec.h:529

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

AV_CODEC_ID_HEVC

@ AV_CODEC_ID_HEVC

Definition: codec_id.h:226

VTContext::frame

CVImageBufferRef frame

Definition: vt_internal.h:36

av_frame_unref

void av_frame_unref(AVFrame *frame)

Unreference all the buffers referenced by frame and reset the frame fields.

Definition: frame.c:610

av_mallocz

void * av_mallocz(size_t size)

Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...

Definition: mem.c:256

AVCodecContext::hw_device_ctx

AVBufferRef * hw_device_ctx

A reference to the AVHWDeviceContext describing the device which will be used by a hardware encoder/d...

Definition: avcodec.h:1507

bytestream2_put_ne32

#define bytestream2_put_ne32

Definition: bytestream.h:129

AVCodecContext::height

int height

Definition: avcodec.h:624

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:663

AVCodecContext::hw_frames_ctx

AVBufferRef * hw_frames_ctx

A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames.

Definition: avcodec.h:1485

AVHWFramesContext

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

Definition: hwcontext.h:115

bytestream2_put_ne16

#define bytestream2_put_ne16

Definition: bytestream.h:127

ret

Definition: filter_design.txt:187

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

ff_videotoolbox_alloc_frame

int ff_videotoolbox_alloc_frame(AVCodecContext *avctx, AVFrame *frame)

Definition: videotoolbox.c:126

AVHWFramesContext::hwctx

void * hwctx

The format-specific data, allocated and freed automatically along with this context.

Definition: hwcontext.h:150

sps

static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)

Definition: cbs_h264_syntax_template.c:260

VIDEOTOOLBOX_ESDS_EXTRADATA_PADDING

#define VIDEOTOOLBOX_ESDS_EXTRADATA_PADDING

Definition: videotoolbox.c:59

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

AVCodecContext

main external API structure.

Definition: avcodec.h:451

status

ov_status_e status

Definition: dnn_backend_openvino.c:100

VTContext::vt_ctx

struct AVVideotoolboxContext * vt_ctx

Definition: vt_internal.h:43

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

ff_mpeg4_videotoolbox_hwaccel

const struct FFHWAccel ff_mpeg4_videotoolbox_hwaccel

AV_PIX_FMT_NONE

@ AV_PIX_FMT_NONE

Definition: pixfmt.h:72

HEVCContext

Definition: hevcdec.h:487

PTLCommon::level_idc

uint8_t level_idc

Definition: ps.h:147

ref