FFmpeg: libavdevice/avfoundation.m Source File

FFmpeg

[フレーム]

libavdevice

avfoundation.m

Go to the documentation of this file.

1 /*

2 * AVFoundation input device

4 *

5 * This file is part of FFmpeg.

6 *

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

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

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

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

11 *

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

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

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

15 * Lesser General Public License for more details.

16 *

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

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

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

20 */

22 /**

23 * @file

24 * AVFoundation input device

25 * @author Thilo Borgmann <thilo.borgmann@mail.de>

26 */

28 #import <AVFoundation/AVFoundation.h>

29 #include <pthread.h>

31 #include "libavutil/channel_layout.h"

32 #include "libavutil/pixdesc.h"

33 #include "libavutil/opt.h"

34 #include "libavutil/avstring.h"

35 #include "libavformat/demux.h"

36 #include "libavformat/internal.h"

37 #include "libavutil/internal.h"

38 #include "libavutil/parseutils.h"

39 #include "libavutil/time.h"

40 #include "libavutil/imgutils.h"

41 #include "avdevice.h"

43 static const int avf_time_base = 1000000;

45 static const AVRational avf_time_base_q = {

46 .num = 1,

47 .den = avf_time_base

48 };

50 struct AVFPixelFormatSpec {

51 enum AVPixelFormat ff_id;

52 OSType avf_id;

53 };

55 static const struct AVFPixelFormatSpec avf_pixel_formats[] = {

56 { AV_PIX_FMT_MONOBLACK, kCVPixelFormatType_1Monochrome },

57 { AV_PIX_FMT_RGB555BE, kCVPixelFormatType_16BE555 },

58 { AV_PIX_FMT_RGB555LE, kCVPixelFormatType_16LE555 },

59 { AV_PIX_FMT_RGB565BE, kCVPixelFormatType_16BE565 },

60 { AV_PIX_FMT_RGB565LE, kCVPixelFormatType_16LE565 },

61 { AV_PIX_FMT_RGB24, kCVPixelFormatType_24RGB },

62 { AV_PIX_FMT_BGR24, kCVPixelFormatType_24BGR },

63 { AV_PIX_FMT_0RGB, kCVPixelFormatType_32ARGB },

64 { AV_PIX_FMT_BGR0, kCVPixelFormatType_32BGRA },

65 { AV_PIX_FMT_0BGR, kCVPixelFormatType_32ABGR },

66 { AV_PIX_FMT_RGB0, kCVPixelFormatType_32RGBA },

67 { AV_PIX_FMT_BGR48BE, kCVPixelFormatType_48RGB },

68 { AV_PIX_FMT_UYVY422, kCVPixelFormatType_422YpCbCr8 },

69 { AV_PIX_FMT_YUVA444P, kCVPixelFormatType_4444YpCbCrA8R },

70 { AV_PIX_FMT_YUVA444P16LE, kCVPixelFormatType_4444AYpCbCr16 },

71 { AV_PIX_FMT_YUV444P, kCVPixelFormatType_444YpCbCr8 },

72 { AV_PIX_FMT_YUV422P16, kCVPixelFormatType_422YpCbCr16 },

73 { AV_PIX_FMT_YUV422P10, kCVPixelFormatType_422YpCbCr10 },

74 { AV_PIX_FMT_YUV444P10, kCVPixelFormatType_444YpCbCr10 },

75 { AV_PIX_FMT_YUV420P, kCVPixelFormatType_420YpCbCr8Planar },

76 { AV_PIX_FMT_NV12, kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange },

77 { AV_PIX_FMT_YUYV422, kCVPixelFormatType_422YpCbCr8_yuvs },

78 #if !TARGET_OS_IPHONE && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1080

79 { AV_PIX_FMT_GRAY8, kCVPixelFormatType_OneComponent8 },

80 #endif

81 { AV_PIX_FMT_NONE, 0 }

82 };

84 typedef struct

85 {

86 AVClass* class;

88 int frames_captured;

89 int audio_frames_captured;

90 pthread_mutex_t frame_lock;

91 id avf_delegate;

92 id avf_audio_delegate;

94 AVRational framerate;

95 int width, height;

97 int capture_cursor;

98 int capture_mouse_clicks;

99 int capture_raw_data;

100 int drop_late_frames;

101 int video_is_muxed;

102 int video_is_screen;

103

104 int list_devices;

105 int video_device_index;

106 int video_stream_index;

107 int audio_device_index;

108 int audio_stream_index;

109

110 char *url;

111 char *video_filename;

112 char *audio_filename;

113

114 int num_video_devices;

115

116 int audio_channels;

117 int audio_bits_per_sample;

118 int audio_float;

119 int audio_be;

120 int audio_signed_integer;

121 int audio_packed;

122 int audio_non_interleaved;

123

124 int32_t *audio_buffer;

125 int audio_buffer_size;

126

127 enum AVPixelFormat pixel_format;

128

129 AVCaptureSession *capture_session;

130 AVCaptureVideoDataOutput *video_output;

131 AVCaptureAudioDataOutput *audio_output;

132 CMSampleBufferRef current_frame;

133 CMSampleBufferRef current_audio_frame;

134

135 AVCaptureDevice *observed_device;

136 #if !TARGET_OS_IPHONE && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1070

137 AVCaptureDeviceTransportControlsPlaybackMode observed_mode;

138 #endif

139 int observed_quit;

140 } AVFContext;

141

142 static void lock_frames(AVFContext* ctx)

143 {

144 pthread_mutex_lock(&ctx->frame_lock);

145 }

146

147 static void unlock_frames(AVFContext* ctx)

148 {

149 pthread_mutex_unlock(&ctx->frame_lock);

150 }

151

152 /** FrameReciever class - delegate for AVCaptureSession

153 */

154 @interface AVFFrameReceiver : NSObject

155 {

156 AVFContext* _context;

157 }

158

159 - (id)initWithContext:(AVFContext*)context;

160

161 - (void) captureOutput:(AVCaptureOutput *)captureOutput

162 didOutputSampleBuffer:(CMSampleBufferRef)videoFrame

163 fromConnection:(AVCaptureConnection *)connection;

164

165 @end

166

167 @implementation AVFFrameReceiver

168

169 - (id)initWithContext:(AVFContext*)context

170 {

171 if (self = [super init]) {

172 _context = context;

173

174 // start observing if a device is set for it

175 #if !TARGET_OS_IPHONE && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1070

176 if (_context->observed_device) {

177 NSString *keyPath = NSStringFromSelector(@selector(transportControlsPlaybackMode));

178 NSKeyValueObservingOptions options = NSKeyValueObservingOptionNew;

179

180 [_context->observed_device addObserver: self

181 forKeyPath: keyPath

182 options: options

183 context: _context];

184 }

185 #endif

186 }

187 return self;

188 }

189

190 - (void)dealloc {

191 // stop observing if a device is set for it

192 #if !TARGET_OS_IPHONE && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1070

193 if (_context->observed_device) {

194 NSString *keyPath = NSStringFromSelector(@selector(transportControlsPlaybackMode));

195 [_context->observed_device removeObserver: self forKeyPath: keyPath];

196 }

197 #endif

198 [super dealloc];

199 }

200

201 - (void)observeValueForKeyPath:(NSString *)keyPath

202 ofObject:(id)object

203 change:(NSDictionary *)change

204 context:(void *)context {

205 if (context == _context) {

206 #if !TARGET_OS_IPHONE && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1070

207 AVCaptureDeviceTransportControlsPlaybackMode mode =

208 [change[NSKeyValueChangeNewKey] integerValue];

209

210 if (mode != _context->observed_mode) {

211 if (mode == AVCaptureDeviceTransportControlsNotPlayingMode) {

212 _context->observed_quit = 1;

213 }

214 _context->observed_mode = mode;

215 }

216 #endif

217 } else {

218 [super observeValueForKeyPath: keyPath

219 ofObject: object

220 change: change

221 context: context];

222 }

223 }

224

225 - (void) captureOutput:(AVCaptureOutput *)captureOutput

226 didOutputSampleBuffer:(CMSampleBufferRef)videoFrame

227 fromConnection:(AVCaptureConnection *)connection

228 {

229 lock_frames(_context);

230

231 if (_context->current_frame != nil) {

232 CFRelease(_context->current_frame);

233 }

234

235 _context->current_frame = (CMSampleBufferRef)CFRetain(videoFrame);

236

237 unlock_frames(_context);

238

239 ++_context->frames_captured;

240 }

241

242 @end

243

244 /** AudioReciever class - delegate for AVCaptureSession

245 */

246 @interface AVFAudioReceiver : NSObject

247 {

248 AVFContext* _context;

249 }

250

251 - (id)initWithContext:(AVFContext*)context;

252

253 - (void) captureOutput:(AVCaptureOutput *)captureOutput

254 didOutputSampleBuffer:(CMSampleBufferRef)audioFrame

255 fromConnection:(AVCaptureConnection *)connection;

256

257 @end

258

259 @implementation AVFAudioReceiver

260

261 - (id)initWithContext:(AVFContext*)context

262 {

263 if (self = [super init]) {

264 _context = context;

265 }

266 return self;

267 }

268

269 - (void) captureOutput:(AVCaptureOutput *)captureOutput

270 didOutputSampleBuffer:(CMSampleBufferRef)audioFrame

271 fromConnection:(AVCaptureConnection *)connection

272 {

273 lock_frames(_context);

274

275 if (_context->current_audio_frame != nil) {

276 CFRelease(_context->current_audio_frame);

277 }

278

279 _context->current_audio_frame = (CMSampleBufferRef)CFRetain(audioFrame);

280

281 unlock_frames(_context);

282

283 ++_context->audio_frames_captured;

284 }

285

286 @end

287

288 static void destroy_context(AVFContext* ctx)

289 {

290 [ctx->capture_session stopRunning];

291

292 [ctx->capture_session release];

293 [ctx->video_output release];

294 [ctx->audio_output release];

295 [ctx->avf_delegate release];

296 [ctx->avf_audio_delegate release];

297

298 ctx->capture_session = NULL;

299 ctx->video_output = NULL;

300 ctx->audio_output = NULL;

301 ctx->avf_delegate = NULL;

302 ctx->avf_audio_delegate = NULL;

303

304 av_freep(&ctx->url);

305 av_freep(&ctx->audio_buffer);

306

307 pthread_mutex_destroy(&ctx->frame_lock);

308

309 if (ctx->current_frame) {

310 CFRelease(ctx->current_frame);

311 }

312 }

313

314 static int parse_device_name(AVFormatContext *s)

315 {

316 AVFContext *ctx = (AVFContext*)s->priv_data;

317 char *save;

318

319 ctx->url = av_strdup(s->url);

320

321 if (!ctx->url)

322 return AVERROR(ENOMEM);

323 if (ctx->url[0] != ':') {

324 ctx->video_filename = av_strtok(ctx->url, ":", &save);

325 ctx->audio_filename = av_strtok(NULL, ":", &save);

326 } else {

327 ctx->audio_filename = av_strtok(ctx->url, ":", &save);

328 }

329 return 0;

330 }

331

332 /**

333 * Configure the video device.

334 *

335 * Configure the video device using a run-time approach to access properties

336 * since formats, activeFormat are available since iOS >= 7.0 or OSX >= 10.7

337 * and activeVideoMaxFrameDuration is available since i0S >= 7.0 and OSX >= 10.9.

338 *

339 * The NSUndefinedKeyException must be handled by the caller of this function.

340 *

341 */

342 static int configure_video_device(AVFormatContext *s, AVCaptureDevice *video_device)

343 {

344 AVFContext *ctx = (AVFContext*)s->priv_data;

345

346 double framerate = av_q2d(ctx->framerate);

347 NSObject *range = nil;

348 NSObject *format = nil;

349 NSObject *selected_range = nil;

350 NSObject *selected_format = nil;

351

352 // try to configure format by formats list

353 // might raise an exception if no format list is given

354 // (then fallback to default, no configuration)

355 @try {

356 for (format in [video_device valueForKey:@"formats"]) {

357 CMFormatDescriptionRef formatDescription;

358 CMVideoDimensions dimensions;

359

360 formatDescription = (CMFormatDescriptionRef) [format performSelector:@selector(formatDescription)];

361 dimensions = CMVideoFormatDescriptionGetDimensions(formatDescription);

362

363 if ((ctx->width == 0 && ctx->height == 0) ||

364 (dimensions.width == ctx->width && dimensions.height == ctx->height)) {

365

366 selected_format = format;

367

368 for (range in [format valueForKey:@"videoSupportedFrameRateRanges"]) {

369 double max_framerate;

370

371 [[range valueForKey:@"maxFrameRate"] getValue:&max_framerate];

372 if (fabs (framerate - max_framerate) < 0.01) {

373 selected_range = range;

374 break;

375 }

376 }

377 }

378 }

379

380 if (!selected_format) {

381 av_log(s, AV_LOG_ERROR, "Selected video size (%dx%d) is not supported by the device.\n",

382 ctx->width, ctx->height);

383 goto unsupported_format;

384 }

385

386 if (!selected_range) {

387 av_log(s, AV_LOG_ERROR, "Selected framerate (%f) is not supported by the device.\n",

388 framerate);

389 if (ctx->video_is_muxed) {

390 av_log(s, AV_LOG_ERROR, "Falling back to default.\n");

391 } else {

392 goto unsupported_format;

393 }

394 }

395

396 if ([video_device lockForConfiguration:NULL] == YES) {

397 if (selected_format) {

398 [video_device setValue:selected_format forKey:@"activeFormat"];

399 }

400 if (selected_range) {

401 NSValue *min_frame_duration = [selected_range valueForKey:@"minFrameDuration"];

402 [video_device setValue:min_frame_duration forKey:@"activeVideoMinFrameDuration"];

403 [video_device setValue:min_frame_duration forKey:@"activeVideoMaxFrameDuration"];

404 }

405 } else {

406 av_log(s, AV_LOG_ERROR, "Could not lock device for configuration.\n");

407 return AVERROR(EINVAL);

408 }

409 } @catch(NSException *e) {

410 av_log(ctx, AV_LOG_WARNING, "Configuration of video device failed, falling back to default.\n");

411 }

412

413 return 0;

414

415 unsupported_format:

416

417 av_log(s, AV_LOG_ERROR, "Supported modes:\n");

418 for (format in [video_device valueForKey:@"formats"]) {

419 CMFormatDescriptionRef formatDescription;

420 CMVideoDimensions dimensions;

421

422 formatDescription = (CMFormatDescriptionRef) [format performSelector:@selector(formatDescription)];

423 dimensions = CMVideoFormatDescriptionGetDimensions(formatDescription);

424

425 for (range in [format valueForKey:@"videoSupportedFrameRateRanges"]) {

426 double min_framerate;

427 double max_framerate;

428

429 [[range valueForKey:@"minFrameRate"] getValue:&min_framerate];

430 [[range valueForKey:@"maxFrameRate"] getValue:&max_framerate];

431 av_log(s, AV_LOG_ERROR, " %dx%d@[%f %f]fps\n",

432 dimensions.width, dimensions.height,

433 min_framerate, max_framerate);

434 }

435 }

436 return AVERROR(EINVAL);

437 }

438

439 static int add_video_device(AVFormatContext *s, AVCaptureDevice *video_device)

440 {

441 AVFContext *ctx = (AVFContext*)s->priv_data;

442 int ret;

443 NSError *error = nil;

444 AVCaptureInput* capture_input = nil;

445 struct AVFPixelFormatSpec pxl_fmt_spec;

446 NSNumber *pixel_format;

447 NSDictionary *capture_dict;

448 dispatch_queue_t queue;

449

450 if (ctx->video_device_index < ctx->num_video_devices) {

451 capture_input = (AVCaptureInput*) [[[AVCaptureDeviceInput alloc] initWithDevice:video_device error:&error] autorelease];

452 } else {

453 capture_input = (AVCaptureInput*) video_device;

454 }

455

456 if (!capture_input) {

457 av_log(s, AV_LOG_ERROR, "Failed to create AV capture input device: %s\n",

458 [[error localizedDescription] UTF8String]);

459 return 1;

460 }

461

462 if ([ctx->capture_session canAddInput:capture_input]) {

463 [ctx->capture_session addInput:capture_input];

464 } else {

465 av_log(s, AV_LOG_ERROR, "can't add video input to capture session\n");

466 return 1;

467 }

468

469 // Attaching output

470 ctx->video_output = [[AVCaptureVideoDataOutput alloc] init];

471

472 if (!ctx->video_output) {

473 av_log(s, AV_LOG_ERROR, "Failed to init AV video output\n");

474 return 1;

475 }

476

477 // Configure device framerate and video size

478 @try {

479 if ((ret = configure_video_device(s, video_device)) < 0) {

480 return ret;

481 }

482 } @catch (NSException *exception) {

483 if (![[exception name] isEqualToString:NSUndefinedKeyException]) {

484 av_log (s, AV_LOG_ERROR, "An error occurred: %s", [exception.reason UTF8String]);

485 return AVERROR_EXTERNAL;

486 }

487 }

488

489 // select pixel format

490 pxl_fmt_spec.ff_id = AV_PIX_FMT_NONE;

491

492 for (int i = 0; avf_pixel_formats[i].ff_id != AV_PIX_FMT_NONE; i++) {

493 if (ctx->pixel_format == avf_pixel_formats[i].ff_id) {

494 pxl_fmt_spec = avf_pixel_formats[i];

495 break;

496 }

497 }

498

499 // check if selected pixel format is supported by AVFoundation

500 if (pxl_fmt_spec.ff_id == AV_PIX_FMT_NONE) {

501 av_log(s, AV_LOG_ERROR, "Selected pixel format (%s) is not supported by AVFoundation.\n",

502 av_get_pix_fmt_name(pxl_fmt_spec.ff_id));

503 return 1;

504 }

505

506 // check if the pixel format is available for this device

507 if ([[ctx->video_output availableVideoCVPixelFormatTypes] indexOfObject:[NSNumber numberWithInt:pxl_fmt_spec.avf_id]] == NSNotFound) {

508 av_log(s, AV_LOG_ERROR, "Selected pixel format (%s) is not supported by the input device.\n",

509 av_get_pix_fmt_name(pxl_fmt_spec.ff_id));

510

511 pxl_fmt_spec.ff_id = AV_PIX_FMT_NONE;

512

513 av_log(s, AV_LOG_ERROR, "Supported pixel formats:\n");

514 for (NSNumber *pxl_fmt in [ctx->video_output availableVideoCVPixelFormatTypes]) {

515 struct AVFPixelFormatSpec pxl_fmt_dummy;

516 pxl_fmt_dummy.ff_id = AV_PIX_FMT_NONE;

517 for (int i = 0; avf_pixel_formats[i].ff_id != AV_PIX_FMT_NONE; i++) {

518 if ([pxl_fmt intValue] == avf_pixel_formats[i].avf_id) {

519 pxl_fmt_dummy = avf_pixel_formats[i];

520 break;

521 }

522 }

523

524 if (pxl_fmt_dummy.ff_id != AV_PIX_FMT_NONE) {

525 av_log(s, AV_LOG_ERROR, " %s\n", av_get_pix_fmt_name(pxl_fmt_dummy.ff_id));

526

527 // select first supported pixel format instead of user selected (or default) pixel format

528 if (pxl_fmt_spec.ff_id == AV_PIX_FMT_NONE) {

529 pxl_fmt_spec = pxl_fmt_dummy;

530 }

531 }

532 }

533

534 // fail if there is no appropriate pixel format or print a warning about overriding the pixel format

535 if (pxl_fmt_spec.ff_id == AV_PIX_FMT_NONE) {

536 return 1;

537 } else {

538 av_log(s, AV_LOG_WARNING, "Overriding selected pixel format to use %s instead.\n",

539 av_get_pix_fmt_name(pxl_fmt_spec.ff_id));

540 }

541 }

542

543 // set videoSettings to an empty dict for receiving raw data of muxed devices

544 if (ctx->capture_raw_data) {

545 ctx->pixel_format = pxl_fmt_spec.ff_id;

546 ctx->video_output.videoSettings = @{ };

547 } else {

548 ctx->pixel_format = pxl_fmt_spec.ff_id;

549 pixel_format = [NSNumber numberWithUnsignedInt:pxl_fmt_spec.avf_id];

550 capture_dict = [NSDictionary dictionaryWithObject:pixel_format

551 forKey:(id)kCVPixelBufferPixelFormatTypeKey];

552

553 [ctx->video_output setVideoSettings:capture_dict];

554 }

555 [ctx->video_output setAlwaysDiscardsLateVideoFrames:ctx->drop_late_frames];

556

557 #if !TARGET_OS_IPHONE && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1070

558 // check for transport control support and set observer device if supported

559 if (!ctx->video_is_screen) {

560 int trans_ctrl = [video_device transportControlsSupported];

561 AVCaptureDeviceTransportControlsPlaybackMode trans_mode = [video_device transportControlsPlaybackMode];

562

563 if (trans_ctrl) {

564 ctx->observed_mode = trans_mode;

565 ctx->observed_device = video_device;

566 }

567 }

568 #endif

569

570 ctx->avf_delegate = [[AVFFrameReceiver alloc] initWithContext:ctx];

571

572 queue = dispatch_queue_create("avf_queue", NULL);

573 [ctx->video_output setSampleBufferDelegate:ctx->avf_delegate queue:queue];

574 dispatch_release(queue);

575

576 if ([ctx->capture_session canAddOutput:ctx->video_output]) {

577 [ctx->capture_session addOutput:ctx->video_output];

578 } else {

579 av_log(s, AV_LOG_ERROR, "can't add video output to capture session\n");

580 return 1;

581 }

582

583 return 0;

584 }

585

586 static int add_audio_device(AVFormatContext *s, AVCaptureDevice *audio_device)

587 {

588 AVFContext *ctx = (AVFContext*)s->priv_data;

589 NSError *error = nil;

590 AVCaptureDeviceInput* audio_dev_input = [[[AVCaptureDeviceInput alloc] initWithDevice:audio_device error:&error] autorelease];

591 dispatch_queue_t queue;

592

593 if (!audio_dev_input) {

594 av_log(s, AV_LOG_ERROR, "Failed to create AV capture input device: %s\n",

595 [[error localizedDescription] UTF8String]);

596 return 1;

597 }

598

599 if ([ctx->capture_session canAddInput:audio_dev_input]) {

600 [ctx->capture_session addInput:audio_dev_input];

601 } else {

602 av_log(s, AV_LOG_ERROR, "can't add audio input to capture session\n");

603 return 1;

604 }

605

606 // Attaching output

607 ctx->audio_output = [[AVCaptureAudioDataOutput alloc] init];

608

609 if (!ctx->audio_output) {

610 av_log(s, AV_LOG_ERROR, "Failed to init AV audio output\n");

611 return 1;

612 }

613

614 ctx->avf_audio_delegate = [[AVFAudioReceiver alloc] initWithContext:ctx];

615

616 queue = dispatch_queue_create("avf_audio_queue", NULL);

617 [ctx->audio_output setSampleBufferDelegate:ctx->avf_audio_delegate queue:queue];

618 dispatch_release(queue);

619

620 if ([ctx->capture_session canAddOutput:ctx->audio_output]) {

621 [ctx->capture_session addOutput:ctx->audio_output];

622 } else {

623 av_log(s, AV_LOG_ERROR, "adding audio output to capture session failed\n");

624 return 1;

625 }

626

627 return 0;

628 }

629

630 static int get_video_config(AVFormatContext *s)

631 {

632 AVFContext *ctx = (AVFContext*)s->priv_data;

633 CVImageBufferRef image_buffer;

634 CMBlockBufferRef block_buffer;

635 CGSize image_buffer_size;

636 AVStream* stream = avformat_new_stream(s, NULL);

637

638 if (!stream) {

639 return 1;

640 }

641

642 // Take stream info from the first frame.

643 while (ctx->frames_captured < 1) {

644 CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, YES);

645 }

646

647 lock_frames(ctx);

648

649 ctx->video_stream_index = stream->index;

650

651 avpriv_set_pts_info(stream, 64, 1, avf_time_base);

652

653 image_buffer = CMSampleBufferGetImageBuffer(ctx->current_frame);

654 block_buffer = CMSampleBufferGetDataBuffer(ctx->current_frame);

655

656 if (image_buffer) {

657 image_buffer_size = CVImageBufferGetEncodedSize(image_buffer);

658

659 stream->codecpar->codec_id = AV_CODEC_ID_RAWVIDEO;

660 stream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;

661 stream->codecpar->width = (int)image_buffer_size.width;

662 stream->codecpar->height = (int)image_buffer_size.height;

663 stream->codecpar->format = ctx->pixel_format;

664 } else {

665 stream->codecpar->codec_id = AV_CODEC_ID_DVVIDEO;

666 stream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;

667 stream->codecpar->format = ctx->pixel_format;

668 }

669

670 CFRelease(ctx->current_frame);

671 ctx->current_frame = nil;

672

673 unlock_frames(ctx);

674

675 return 0;

676 }

677

678 static int get_audio_config(AVFormatContext *s)

679 {

680 AVFContext *ctx = (AVFContext*)s->priv_data;

681 CMFormatDescriptionRef format_desc;

682 AVStream* stream = avformat_new_stream(s, NULL);

683

684 if (!stream) {

685 return 1;

686 }

687

688 // Take stream info from the first frame.

689 while (ctx->audio_frames_captured < 1) {

690 CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.1, YES);

691 }

692

693 lock_frames(ctx);

694

695 ctx->audio_stream_index = stream->index;

696

697 avpriv_set_pts_info(stream, 64, 1, avf_time_base);

698

699 format_desc = CMSampleBufferGetFormatDescription(ctx->current_audio_frame);

700 const AudioStreamBasicDescription *basic_desc = CMAudioFormatDescriptionGetStreamBasicDescription(format_desc);

701

702 if (!basic_desc) {

703 unlock_frames(ctx);

704 av_log(s, AV_LOG_ERROR, "audio format not available\n");

705 return 1;

706 }

707

708 stream->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;

709 stream->codecpar->sample_rate = basic_desc->mSampleRate;

710 av_channel_layout_default(&stream->codecpar->ch_layout, basic_desc->mChannelsPerFrame);

711

712 ctx->audio_channels = basic_desc->mChannelsPerFrame;

713 ctx->audio_bits_per_sample = basic_desc->mBitsPerChannel;

714 ctx->audio_float = basic_desc->mFormatFlags & kAudioFormatFlagIsFloat;

715 ctx->audio_be = basic_desc->mFormatFlags & kAudioFormatFlagIsBigEndian;

716 ctx->audio_signed_integer = basic_desc->mFormatFlags & kAudioFormatFlagIsSignedInteger;

717 ctx->audio_packed = basic_desc->mFormatFlags & kAudioFormatFlagIsPacked;

718 ctx->audio_non_interleaved = basic_desc->mFormatFlags & kAudioFormatFlagIsNonInterleaved;

719

720 if (basic_desc->mFormatID == kAudioFormatLinearPCM &&

721 ctx->audio_float &&

722 ctx->audio_bits_per_sample == 32 &&

723 ctx->audio_packed) {

724 stream->codecpar->codec_id = ctx->audio_be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;

725 } else if (basic_desc->mFormatID == kAudioFormatLinearPCM &&

726 ctx->audio_signed_integer &&

727 ctx->audio_bits_per_sample == 16 &&

728 ctx->audio_packed) {

729 stream->codecpar->codec_id = ctx->audio_be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;

730 } else if (basic_desc->mFormatID == kAudioFormatLinearPCM &&

731 ctx->audio_signed_integer &&

732 ctx->audio_bits_per_sample == 24 &&

733 ctx->audio_packed) {

734 stream->codecpar->codec_id = ctx->audio_be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;

735 } else if (basic_desc->mFormatID == kAudioFormatLinearPCM &&

736 ctx->audio_signed_integer &&

737 ctx->audio_bits_per_sample == 32 &&

738 ctx->audio_packed) {

739 stream->codecpar->codec_id = ctx->audio_be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;

740 } else {

741 unlock_frames(ctx);

742 av_log(s, AV_LOG_ERROR, "audio format is not supported\n");

743 return 1;

744 }

745

746 if (ctx->audio_non_interleaved) {

747 CMBlockBufferRef block_buffer = CMSampleBufferGetDataBuffer(ctx->current_audio_frame);

748 ctx->audio_buffer_size = CMBlockBufferGetDataLength(block_buffer);

749 ctx->audio_buffer = av_malloc(ctx->audio_buffer_size);

750 if (!ctx->audio_buffer) {

751 unlock_frames(ctx);

752 av_log(s, AV_LOG_ERROR, "error allocating audio buffer\n");

753 return 1;

754 }

755 }

756

757 CFRelease(ctx->current_audio_frame);

758 ctx->current_audio_frame = nil;

759

760 unlock_frames(ctx);

761

762 return 0;

763 }

764

765 static NSArray* getDevicesWithMediaType(AVMediaType mediaType) {

766 #if ((TARGET_OS_IPHONE && __IPHONE_OS_VERSION_MIN_REQUIRED >= 100000) || (TARGET_OS_OSX && __MAC_OS_X_VERSION_MIN_REQUIRED >= 101500))

767 NSMutableArray *deviceTypes = nil;

768 if (mediaType == AVMediaTypeVideo) {

769 deviceTypes = [NSMutableArray arrayWithArray:@[AVCaptureDeviceTypeBuiltInWideAngleCamera]];

770 #if (TARGET_OS_IPHONE && __IPHONE_OS_VERSION_MIN_REQUIRED >= 100000)

771 [deviceTypes addObject: AVCaptureDeviceTypeBuiltInDualCamera];

772 [deviceTypes addObject: AVCaptureDeviceTypeBuiltInTelephotoCamera];

773 #endif

774 #if (TARGET_OS_IPHONE && __IPHONE_OS_VERSION_MIN_REQUIRED >= 110100)

775 [deviceTypes addObject: AVCaptureDeviceTypeBuiltInTrueDepthCamera];

776 #endif

777 #if (TARGET_OS_IPHONE && __IPHONE_OS_VERSION_MIN_REQUIRED >= 130000)

778 [deviceTypes addObject: AVCaptureDeviceTypeBuiltInTripleCamera];

779 [deviceTypes addObject: AVCaptureDeviceTypeBuiltInDualWideCamera];

780 [deviceTypes addObject: AVCaptureDeviceTypeBuiltInUltraWideCamera];

781 #endif

782 #if (TARGET_OS_OSX && __MAC_OS_X_VERSION_MIN_REQUIRED >= 130000)

783 [deviceTypes addObject: AVCaptureDeviceTypeDeskViewCamera];

784 #endif

785 #if (TARGET_OS_IPHONE && __IPHONE_OS_VERSION_MIN_REQUIRED >= 150400)

786 [deviceTypes addObject: AVCaptureDeviceTypeBuiltInLiDARDepthCamera];

787 #endif

788 #if (TARGET_OS_IPHONE && __IPHONE_OS_VERSION_MIN_REQUIRED >= 170000 || (TARGET_OS_OSX && __MAC_OS_X_VERSION_MIN_REQUIRED >= 140000))

789 [deviceTypes addObject: AVCaptureDeviceTypeContinuityCamera];

790 [deviceTypes addObject: AVCaptureDeviceTypeExternal];

791 #elif (TARGET_OS_OSX && __MAC_OS_X_VERSION_MIN_REQUIRED < 140000)

792 [deviceTypes addObject: AVCaptureDeviceTypeExternalUnknown];

793 #endif

794 } else if (mediaType == AVMediaTypeAudio) {

795 #if (TARGET_OS_IPHONE && __IPHONE_OS_VERSION_MIN_REQUIRED >= 170000 || (TARGET_OS_OSX && __MAC_OS_X_VERSION_MIN_REQUIRED >= 140000))

796 deviceTypes = [NSMutableArray arrayWithArray:@[AVCaptureDeviceTypeMicrophone]];

797 #else

798 deviceTypes = [NSMutableArray arrayWithArray:@[AVCaptureDeviceTypeBuiltInMicrophone]];

799 #endif

800 } else if (mediaType == AVMediaTypeMuxed) {

801 #if (TARGET_OS_IPHONE && __IPHONE_OS_VERSION_MIN_REQUIRED >= 170000 || (TARGET_OS_OSX && __MAC_OS_X_VERSION_MIN_REQUIRED >= 140000))

802 deviceTypes = [NSMutableArray arrayWithArray:@[AVCaptureDeviceTypeExternal]];

803 #elif (TARGET_OS_OSX && __MAC_OS_X_VERSION_MIN_REQUIRED < 140000)

804 deviceTypes = [NSMutableArray arrayWithArray:@[AVCaptureDeviceTypeExternalUnknown]];

805 #else

806 return nil;

807 #endif

808 } else {

809 return nil;

810 }

811

812 AVCaptureDeviceDiscoverySession *captureDeviceDiscoverySession =

813 [AVCaptureDeviceDiscoverySession

814 discoverySessionWithDeviceTypes:deviceTypes

815 mediaType:mediaType

816 position:AVCaptureDevicePositionUnspecified];

817 return [captureDeviceDiscoverySession devices];

818 #else

819 return [AVCaptureDevice devicesWithMediaType:mediaType];

820 #endif

821 }

822

823 static int avf_read_header(AVFormatContext *s)

824 {

825 int ret = 0;

826 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

827 uint32_t num_screens = 0;

828 AVFContext *ctx = (AVFContext*)s->priv_data;

829 AVCaptureDevice *video_device = nil;

830 AVCaptureDevice *audio_device = nil;

831 // Find capture device

832 NSArray *devices = getDevicesWithMediaType(AVMediaTypeVideo);

833 NSArray *devices_muxed = getDevicesWithMediaType(AVMediaTypeMuxed);

834

835 ctx->num_video_devices = [devices count] + [devices_muxed count];

836

837 pthread_mutex_init(&ctx->frame_lock, NULL);

838

839 #if !TARGET_OS_IPHONE && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1070

840 CGGetActiveDisplayList(0, NULL, &num_screens);

841 #endif

842

843 // List devices if requested

844 if (ctx->list_devices) {

845 int index = 0;

846 av_log(ctx, AV_LOG_INFO, "AVFoundation video devices:\n");

847 for (AVCaptureDevice *device in devices) {

848 const char *name = [[device localizedName] UTF8String];

849 index = [devices indexOfObject:device];

850 av_log(ctx, AV_LOG_INFO, "[%d] %s\n", index, name);

851 }

852 for (AVCaptureDevice *device in devices_muxed) {

853 const char *name = [[device localizedName] UTF8String];

854 index = [devices count] + [devices_muxed indexOfObject:device];

855 av_log(ctx, AV_LOG_INFO, "[%d] %s\n", index, name);

856 }

857 #if !TARGET_OS_IPHONE && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1070

858 if (num_screens > 0) {

859 CGDirectDisplayID screens[num_screens];

860 CGGetActiveDisplayList(num_screens, screens, &num_screens);

861 for (int i = 0; i < num_screens; i++) {

862 av_log(ctx, AV_LOG_INFO, "[%d] Capture screen %d\n", ctx->num_video_devices + i, i);

863 }

864 }

865 #endif

866

867 av_log(ctx, AV_LOG_INFO, "AVFoundation audio devices:\n");

868 devices = getDevicesWithMediaType(AVMediaTypeAudio);

869 for (AVCaptureDevice *device in devices) {

870 const char *name = [[device localizedName] UTF8String];

871 int index = [devices indexOfObject:device];

872 av_log(ctx, AV_LOG_INFO, "[%d] %s\n", index, name);

873 }

874 goto fail;

875 }

876

877 // parse input filename for video and audio device

878 ret = parse_device_name(s);

879 if (ret)

880 goto fail;

881

882 // check for device index given in filename

883 if (ctx->video_device_index == -1 && ctx->video_filename) {

884 sscanf(ctx->video_filename, "%d", &ctx->video_device_index);

885 }

886 if (ctx->audio_device_index == -1 && ctx->audio_filename) {

887 sscanf(ctx->audio_filename, "%d", &ctx->audio_device_index);

888 }

889

890 if (ctx->video_device_index >= 0) {

891 if (ctx->video_device_index < ctx->num_video_devices) {

892 if (ctx->video_device_index < [devices count]) {

893 video_device = [devices objectAtIndex:ctx->video_device_index];

894 } else {

895 video_device = [devices_muxed objectAtIndex:(ctx->video_device_index - [devices count])];

896 ctx->video_is_muxed = 1;

897 }

898 } else if (ctx->video_device_index < ctx->num_video_devices + num_screens) {

899 #if !TARGET_OS_IPHONE && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1070

900 CGDirectDisplayID screens[num_screens];

901 CGGetActiveDisplayList(num_screens, screens, &num_screens);

902 AVCaptureScreenInput* capture_screen_input = [[[AVCaptureScreenInput alloc] initWithDisplayID:screens[ctx->video_device_index - ctx->num_video_devices]] autorelease];

903

904 if (ctx->framerate.num > 0) {

905 capture_screen_input.minFrameDuration = CMTimeMake(ctx->framerate.den, ctx->framerate.num);

906 }

907

908 #if !TARGET_OS_IPHONE && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1080

909 if (ctx->capture_cursor) {

910 capture_screen_input.capturesCursor = YES;

911 } else {

912 capture_screen_input.capturesCursor = NO;

913 }

914 #endif

915

916 if (ctx->capture_mouse_clicks) {

917 capture_screen_input.capturesMouseClicks = YES;

918 } else {

919 capture_screen_input.capturesMouseClicks = NO;

920 }

921

922 video_device = (AVCaptureDevice*) capture_screen_input;

923 ctx->video_is_screen = 1;

924 #endif

925 } else {

926 av_log(ctx, AV_LOG_ERROR, "Invalid device index\n");

927 goto fail;

928 }

929 } else if (ctx->video_filename &&

930 strncmp(ctx->video_filename, "none", 4)) {

931 if (!strncmp(ctx->video_filename, "default", 7)) {

932 video_device = [AVCaptureDevice defaultDeviceWithMediaType:AVMediaTypeVideo];

933 } else {

934 // looking for video inputs

935 for (AVCaptureDevice *device in devices) {

936 if (!strncmp(ctx->video_filename, [[device localizedName] UTF8String], strlen(ctx->video_filename))) {

937 video_device = device;

938 break;

939 }

940 }

941 // looking for muxed inputs

942 for (AVCaptureDevice *device in devices_muxed) {

943 if (!strncmp(ctx->video_filename, [[device localizedName] UTF8String], strlen(ctx->video_filename))) {

944 video_device = device;

945 ctx->video_is_muxed = 1;

946 break;

947 }

948 }

949

950 #if !TARGET_OS_IPHONE && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1070

951 // looking for screen inputs

952 if (!video_device) {

953 int idx;

954 if(sscanf(ctx->video_filename, "Capture screen %d", &idx) && idx < num_screens) {

955 CGDirectDisplayID screens[num_screens];

956 CGGetActiveDisplayList(num_screens, screens, &num_screens);

957 AVCaptureScreenInput* capture_screen_input = [[[AVCaptureScreenInput alloc] initWithDisplayID:screens[idx]] autorelease];

958 video_device = (AVCaptureDevice*) capture_screen_input;

959 ctx->video_device_index = ctx->num_video_devices + idx;

960 ctx->video_is_screen = 1;

961

962 if (ctx->framerate.num > 0) {

963 capture_screen_input.minFrameDuration = CMTimeMake(ctx->framerate.den, ctx->framerate.num);

964 }

965

966 #if !TARGET_OS_IPHONE && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1080

967 if (ctx->capture_cursor) {

968 capture_screen_input.capturesCursor = YES;

969 } else {

970 capture_screen_input.capturesCursor = NO;

971 }

972 #endif

973

974 if (ctx->capture_mouse_clicks) {

975 capture_screen_input.capturesMouseClicks = YES;

976 } else {

977 capture_screen_input.capturesMouseClicks = NO;

978 }

979 }

980 }

981 #endif

982 }

983

984 if (!video_device) {

985 av_log(ctx, AV_LOG_ERROR, "Video device not found\n");

986 goto fail;

987 }

988 }

989

990 // get audio device

991 if (ctx->audio_device_index >= 0) {

992 NSArray *devices = getDevicesWithMediaType(AVMediaTypeAudio);

993

994 if (ctx->audio_device_index >= [devices count]) {

995 av_log(ctx, AV_LOG_ERROR, "Invalid audio device index\n");

996 goto fail;

997 }

998

999 audio_device = [devices objectAtIndex:ctx->audio_device_index];

1000 } else if (ctx->audio_filename &&

1001 strncmp(ctx->audio_filename, "none", 4)) {

1002 if (!strncmp(ctx->audio_filename, "default", 7)) {

1003 audio_device = [AVCaptureDevice defaultDeviceWithMediaType:AVMediaTypeAudio];

1004 } else {

1005 NSArray *devices = getDevicesWithMediaType(AVMediaTypeAudio);

1006

1007 for (AVCaptureDevice *device in devices) {

1008 if (!strncmp(ctx->audio_filename, [[device localizedName] UTF8String], strlen(ctx->audio_filename))) {

1009 audio_device = device;

1010 break;

1011 }

1012 }

1013 }

1014

1015 if (!audio_device) {

1016 av_log(ctx, AV_LOG_ERROR, "Audio device not found\n");

1017 goto fail;

1018 }

1019 }

1020

1021 // Video nor Audio capture device not found, looking for AVMediaTypeVideo/Audio

1022 if (!video_device && !audio_device) {

1023 av_log(s, AV_LOG_ERROR, "No AV capture device found\n");

1024 goto fail;

1025 }

1026

1027 if (video_device) {

1028 if (ctx->video_device_index < ctx->num_video_devices) {

1029 av_log(s, AV_LOG_DEBUG, "'%s' opened\n", [[video_device localizedName] UTF8String]);

1030 } else {

1031 av_log(s, AV_LOG_DEBUG, "'%s' opened\n", [[video_device description] UTF8String]);

1032 }

1033 }

1034 if (audio_device) {

1035 av_log(s, AV_LOG_DEBUG, "audio device '%s' opened\n", [[audio_device localizedName] UTF8String]);

1036 }

1037

1038 // Initialize capture session

1039 ctx->capture_session = [[AVCaptureSession alloc] init];

1040

1041 if (video_device && add_video_device(s, video_device)) {

1042 goto fail;

1043 }

1044 if (audio_device && add_audio_device(s, audio_device)) {

1045 }

1046

1047 [ctx->capture_session startRunning];

1048

1049 /* Unlock device configuration only after the session is started so it

1050 * does not reset the capture formats */

1051 if (!ctx->video_is_screen) {

1052 [video_device unlockForConfiguration];

1053 }

1054

1055 if (video_device && get_video_config(s)) {

1056 goto fail;

1057 }

1058

1059 // set audio stream

1060 if (audio_device && get_audio_config(s)) {

1061 goto fail;

1062 }

1063

1064 [pool release];

1065 return 0;

1066

1067 fail:

1068 [pool release];

1069 destroy_context(ctx);

1070 if (ret)

1071 return ret;

1072 return AVERROR(EIO);

1073 }

1074

1075 static int copy_cvpixelbuffer(AVFormatContext *s,

1076 CVPixelBufferRef image_buffer,

1077 AVPacket *pkt)

1078 {

1079 AVFContext *ctx = s->priv_data;

1080 int src_linesize[4];

1081 const uint8_t *src_data[4];

1082 int width = CVPixelBufferGetWidth(image_buffer);

1083 int height = CVPixelBufferGetHeight(image_buffer);

1084 int status;

1085

1086 memset(src_linesize, 0, sizeof(src_linesize));

1087 memset(src_data, 0, sizeof(src_data));

1088

1089 status = CVPixelBufferLockBaseAddress(image_buffer, 0);

1090 if (status != kCVReturnSuccess) {

1091 av_log(s, AV_LOG_ERROR, "Could not lock base address: %d (%dx%d)\n", status, width, height);

1092 return AVERROR_EXTERNAL;

1093 }

1094

1095 if (CVPixelBufferIsPlanar(image_buffer)) {

1096 size_t plane_count = CVPixelBufferGetPlaneCount(image_buffer);

1097 int i;

1098 for(i = 0; i < plane_count; i++){

1099 src_linesize[i] = CVPixelBufferGetBytesPerRowOfPlane(image_buffer, i);

1100 src_data[i] = CVPixelBufferGetBaseAddressOfPlane(image_buffer, i);

1101 }

1102 } else {

1103 src_linesize[0] = CVPixelBufferGetBytesPerRow(image_buffer);

1104 src_data[0] = CVPixelBufferGetBaseAddress(image_buffer);

1105 }

1106

1107 status = av_image_copy_to_buffer(pkt->data, pkt->size,

1108 src_data, src_linesize,

1109 ctx->pixel_format, width, height, 1);

1110

1111

1112

1113 CVPixelBufferUnlockBaseAddress(image_buffer, 0);

1114

1115 return status;

1116 }

1117

1118 static int avf_read_packet(AVFormatContext *s, AVPacket *pkt)

1119 {

1120 AVFContext* ctx = (AVFContext*)s->priv_data;

1121

1122 do {

1123 CVImageBufferRef image_buffer;

1124 CMBlockBufferRef block_buffer;

1125 lock_frames(ctx);

1126

1127 if (ctx->current_frame != nil) {

1128 int status;

1129 int length = 0;

1130

1131 image_buffer = CMSampleBufferGetImageBuffer(ctx->current_frame);

1132 block_buffer = CMSampleBufferGetDataBuffer(ctx->current_frame);

1133

1134 if (image_buffer != nil) {

1135 length = (int)CVPixelBufferGetDataSize(image_buffer);

1136 } else if (block_buffer != nil) {

1137 length = (int)CMBlockBufferGetDataLength(block_buffer);

1138 } else {

1139 unlock_frames(ctx);

1140 return AVERROR(EINVAL);

1141 }

1142

1143 if (av_new_packet(pkt, length) < 0) {

1144 unlock_frames(ctx);

1145 return AVERROR(EIO);

1146 }

1147

1148 CMItemCount count;

1149 CMSampleTimingInfo timing_info;

1150

1151 if (CMSampleBufferGetOutputSampleTimingInfoArray(ctx->current_frame, 1, &timing_info, &count) == noErr) {

1152 AVRational timebase_q = av_make_q(1, timing_info.presentationTimeStamp.timescale);

1153 pkt->pts = pkt->dts = av_rescale_q(timing_info.presentationTimeStamp.value, timebase_q, avf_time_base_q);

1154 }

1155

1156 pkt->stream_index = ctx->video_stream_index;

1157 pkt->flags |= AV_PKT_FLAG_KEY;

1158

1159 if (image_buffer) {

1160 status = copy_cvpixelbuffer(s, image_buffer, pkt);

1161 } else {

1162 status = 0;

1163 OSStatus ret = CMBlockBufferCopyDataBytes(block_buffer, 0, pkt->size, pkt->data);

1164 if (ret != kCMBlockBufferNoErr) {

1165 status = AVERROR(EIO);

1166 }

1167 }

1168 CFRelease(ctx->current_frame);

1169 ctx->current_frame = nil;

1170

1171 if (status < 0) {

1172 unlock_frames(ctx);

1173 return status;

1174 }

1175 } else if (ctx->current_audio_frame != nil) {

1176 CMBlockBufferRef block_buffer = CMSampleBufferGetDataBuffer(ctx->current_audio_frame);

1177 int block_buffer_size = CMBlockBufferGetDataLength(block_buffer);

1178

1179 if (!block_buffer || !block_buffer_size) {

1180 unlock_frames(ctx);

1181 return AVERROR(EIO);

1182 }

1183

1184 if (ctx->audio_non_interleaved && block_buffer_size > ctx->audio_buffer_size) {

1185 unlock_frames(ctx);

1186 return AVERROR_BUFFER_TOO_SMALL;

1187 }

1188

1189 if (av_new_packet(pkt, block_buffer_size) < 0) {

1190 unlock_frames(ctx);

1191 return AVERROR(EIO);

1192 }

1193

1194 CMItemCount count;

1195 CMSampleTimingInfo timing_info;

1196

1197 if (CMSampleBufferGetOutputSampleTimingInfoArray(ctx->current_audio_frame, 1, &timing_info, &count) == noErr) {

1198 AVRational timebase_q = av_make_q(1, timing_info.presentationTimeStamp.timescale);

1199 pkt->pts = pkt->dts = av_rescale_q(timing_info.presentationTimeStamp.value, timebase_q, avf_time_base_q);

1200 }

1201

1202 pkt->stream_index = ctx->audio_stream_index;

1203 pkt->flags |= AV_PKT_FLAG_KEY;

1204

1205 if (ctx->audio_non_interleaved) {

1206 int sample, c, shift, num_samples;

1207

1208 OSStatus ret = CMBlockBufferCopyDataBytes(block_buffer, 0, pkt->size, ctx->audio_buffer);

1209 if (ret != kCMBlockBufferNoErr) {

1210 unlock_frames(ctx);

1211 return AVERROR(EIO);

1212 }

1213

1214 num_samples = pkt->size / (ctx->audio_channels * (ctx->audio_bits_per_sample >> 3));

1215

1216 // transform decoded frame into output format

1217 #define INTERLEAVE_OUTPUT(bps) \

1218 { \

1219 int##bps##_t **src; \

1220 int##bps##_t *dest; \

1221 src = av_malloc(ctx->audio_channels * sizeof(int##bps##_t*)); \

1222 if (!src) { \

1223 unlock_frames(ctx); \

1224 return AVERROR(EIO); \

1225 } \

1226 \

1227 for (c = 0; c < ctx->audio_channels; c++) { \

1228 src[c] = ((int##bps##_t*)ctx->audio_buffer) + c * num_samples; \

1229 } \

1230 dest = (int##bps##_t*)pkt->data; \

1231 shift = bps - ctx->audio_bits_per_sample; \

1232 for (sample = 0; sample < num_samples; sample++) \

1233 for (c = 0; c < ctx->audio_channels; c++) \

1234 *dest++ = src[c][sample] << shift; \

1235 av_freep(&src); \

1236 }

1237

1238 if (ctx->audio_bits_per_sample <= 16) {

1239 INTERLEAVE_OUTPUT(16)

1240 } else {

1241 INTERLEAVE_OUTPUT(32)

1242 }

1243 } else {

1244 OSStatus ret = CMBlockBufferCopyDataBytes(block_buffer, 0, pkt->size, pkt->data);

1245 if (ret != kCMBlockBufferNoErr) {

1246 unlock_frames(ctx);

1247 return AVERROR(EIO);

1248 }

1249 }

1250

1251 CFRelease(ctx->current_audio_frame);

1252 ctx->current_audio_frame = nil;

1253 } else {

1254 pkt->data = NULL;

1255 unlock_frames(ctx);

1256 if (ctx->observed_quit) {

1257 return AVERROR_EOF;

1258 } else {

1259 return AVERROR(EAGAIN);

1260 }

1261 }

1262

1263 unlock_frames(ctx);

1264 } while (!pkt->data);

1265

1266 return 0;

1267 }

1268

1269 static int avf_close(AVFormatContext *s)

1270 {

1271 AVFContext* ctx = (AVFContext*)s->priv_data;

1272 destroy_context(ctx);

1273 return 0;

1274 }

1275

1276 static const AVOption options[] = {

1277 { "list_devices", "list available devices", offsetof(AVFContext, list_devices), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, AV_OPT_FLAG_DECODING_PARAM },

1278 { "video_device_index", "select video device by index for devices with same name (starts at 0)", offsetof(AVFContext, video_device_index), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, AV_OPT_FLAG_DECODING_PARAM },

1279 { "audio_device_index", "select audio device by index for devices with same name (starts at 0)", offsetof(AVFContext, audio_device_index), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, AV_OPT_FLAG_DECODING_PARAM },

1280 { "pixel_format", "set pixel format", offsetof(AVFContext, pixel_format), AV_OPT_TYPE_PIXEL_FMT, {.i64 = AV_PIX_FMT_YUV420P}, 0, INT_MAX, AV_OPT_FLAG_DECODING_PARAM},

1281 { "framerate", "set frame rate", offsetof(AVFContext, framerate), AV_OPT_TYPE_VIDEO_RATE, {.str = "ntsc"}, 0, INT_MAX, AV_OPT_FLAG_DECODING_PARAM },

1282 { "video_size", "set video size", offsetof(AVFContext, width), AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL}, 0, 0, AV_OPT_FLAG_DECODING_PARAM },

1283 { "capture_cursor", "capture the screen cursor", offsetof(AVFContext, capture_cursor), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, AV_OPT_FLAG_DECODING_PARAM },

1284 { "capture_mouse_clicks", "capture the screen mouse clicks", offsetof(AVFContext, capture_mouse_clicks), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, AV_OPT_FLAG_DECODING_PARAM },

1285 { "capture_raw_data", "capture the raw data from device connection", offsetof(AVFContext, capture_raw_data), AV_OPT_TYPE_BOOL, {.i64=0}, 0, 1, AV_OPT_FLAG_DECODING_PARAM },

1286 { "drop_late_frames", "drop frames that are available later than expected", offsetof(AVFContext, drop_late_frames), AV_OPT_TYPE_BOOL, {.i64=1}, 0, 1, AV_OPT_FLAG_DECODING_PARAM },

1287

1288 { NULL },

1289 };

1290

1291 static const AVClass avf_class = {

1292 .class_name = "AVFoundation indev",

1293 .item_name = av_default_item_name,

1294 .option = options,

1295 .version = LIBAVUTIL_VERSION_INT,

1296 .category = AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT,

1297 };

1298

1299 const FFInputFormat ff_avfoundation_demuxer = {

1300 .p.name = "avfoundation",

1301 .p.long_name = NULL_IF_CONFIG_SMALL("AVFoundation input device"),

1302 .p.flags = AVFMT_NOFILE,

1303 .p.priv_class = &avf_class,

1304 .priv_data_size = sizeof(AVFContext),

1305 .read_header = avf_read_header,

1306 .read_packet = avf_read_packet,

1307 .read_close = avf_close,

1308 };

error

static void error(const char *err)

Definition: target_bsf_fuzzer.c:31

AV_CODEC_ID_PCM_S16LE

@ AV_CODEC_ID_PCM_S16LE

Definition: codec_id.h:328

pthread_mutex_t

_fmutex pthread_mutex_t

Definition: os2threads.h:53

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

AV_CODEC_ID_PCM_F32BE

@ AV_CODEC_ID_PCM_F32BE

Definition: codec_id.h:348

AVPixelFormat

Pixel format.

Definition: pixfmt.h:71

name

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 default minimum maximum flags name is the option name

Definition: writing_filters.txt:88

AVFContext::audio_buffer_size

int audio_buffer_size

Definition: avfoundation.m:125

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

opt.h

AVFContext::audio_float

int audio_float

Definition: avfoundation.m:118

AVFContext::observed_quit

int observed_quit

Definition: avfoundation.m:139

unlock_frames

static void unlock_frames(AVFContext *ctx)

Definition: avfoundation.m:147

avformat_new_stream

AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)

Add a new stream to a media file.

AVERROR_EOF

#define AVERROR_EOF

End of file.

Definition: error.h:57

AV_OPT_TYPE_VIDEO_RATE

@ AV_OPT_TYPE_VIDEO_RATE

offset must point to AVRational

Definition: opt.h:248

pthread_mutex_init

static av_always_inline int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr)

Definition: os2threads.h:104

AV_CODEC_ID_RAWVIDEO

@ AV_CODEC_ID_RAWVIDEO

Definition: codec_id.h:65

AVFContext::current_audio_frame

CMSampleBufferRef current_audio_frame

Definition: avfoundation.m:133

pixdesc.h

AVFContext::audio_frames_captured

int audio_frames_captured

Definition: avfoundation.m:89

AVPacket::data

uint8_t * data

Definition: packet.h:522

AVOption

AVOption.

Definition: opt.h:346

AV_PIX_FMT_BGR24

@ AV_PIX_FMT_BGR24

packed RGB 8:8:8, 24bpp, BGRBGR...

Definition: pixfmt.h:76

AV_PKT_FLAG_KEY

#define AV_PKT_FLAG_KEY

The packet contains a keyframe.

Definition: packet.h:577

parse_device_name

static int parse_device_name(AVFormatContext *s)

Definition: avfoundation.m:314

AV_PIX_FMT_RGB555BE

@ AV_PIX_FMT_RGB555BE

packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian , X=unused/undefined

Definition: pixfmt.h:114

AVFContext::audio_channels

int audio_channels

Definition: avfoundation.m:116

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:30

AVFContext::video_filename

char * video_filename

Definition: avfoundation.m:111

AVFPixelFormatSpec::avf_id

OSType avf_id

Definition: avfoundation.m:52

AVFContext::audio_be

int audio_be

Definition: avfoundation.m:119

AVFContext::capture_cursor

int capture_cursor

Definition: avfoundation.m:97

avpriv_set_pts_info

void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)

Set the time base and wrapping info for a given stream.

Definition: avformat.c:853

AV_CODEC_ID_PCM_S16BE

@ AV_CODEC_ID_PCM_S16BE

Definition: codec_id.h:329

fail

#define fail()

Definition: checkasm.h:179

avf_close

static int avf_close(AVFormatContext *s)

Definition: avfoundation.m:1269

avf_time_base

static const int avf_time_base

Definition: avfoundation.m:43

read_close

static av_cold int read_close(AVFormatContext *ctx)

Definition: libcdio.c:143

AVFContext::current_frame

CMSampleBufferRef current_frame

Definition: avfoundation.m:132

AVFPixelFormatSpec::ff_id

enum AVPixelFormat ff_id

Definition: avfoundation.m:51

AVFContext::observed_device

AVCaptureDevice * observed_device

Definition: avfoundation.m:135

AVERROR_BUFFER_TOO_SMALL

#define AVERROR_BUFFER_TOO_SMALL

Buffer too small.

Definition: error.h:53

AVRational::num

int num

Numerator.

Definition: rational.h:59

AVFContext::framerate

AVRational framerate

Definition: avfoundation.m:94

AV_PIX_FMT_YUV444P10

#define AV_PIX_FMT_YUV444P10

Definition: pixfmt.h:481

description

Tag description

Definition: snow.txt:206

pkt

AVPacket * pkt

Definition: movenc.c:59

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

avf_time_base_q

static const AVRational avf_time_base_q

Definition: avfoundation.m:45

AV_PIX_FMT_YUV422P16

#define AV_PIX_FMT_YUV422P16

Definition: pixfmt.h:490

read_packet

static int read_packet(void *opaque, uint8_t *buf, int buf_size)

Definition: avio_read_callback.c:41

AVFContext::num_video_devices

int num_video_devices

Definition: avfoundation.m:114

INTERLEAVE_OUTPUT

#define INTERLEAVE_OUTPUT(bps)

width

#define width

getDevicesWithMediaType

static NSArray * getDevicesWithMediaType(AVMediaType mediaType)

Definition: avfoundation.m:765

#define s(width, name)

Definition: cbs_vp9.c:198

av_new_packet

int av_new_packet(AVPacket *pkt, int size)

Allocate the payload of a packet and initialize its fields with default values.

Definition: avpacket.c:98

format

AVInputFormat::name

const char * name

A comma separated list of short names for the format.

Definition: avformat.h:553

AVFAudioReceiver::_context

AVFContext * _context

Definition: avfoundation.m:248

options

static const AVOption options[]

Definition: avfoundation.m:1276

add_audio_device

static int add_audio_device(AVFormatContext *s, AVCaptureDevice *audio_device)

Definition: avfoundation.m:586

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

av_q2d

static double av_q2d(AVRational a)

Convert an AVRational to a double.

Definition: rational.h:104

av_strtok

char * av_strtok(char *s, const char *delim, char **saveptr)

Split the string into several tokens which can be accessed by successive calls to av_strtok().

Definition: avstring.c:178

AVFContext::capture_mouse_clicks

int capture_mouse_clicks

Definition: avfoundation.m:98

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:201

ctx

AVFormatContext * ctx

Definition: movenc.c:48

AVFContext::frame_lock

pthread_mutex_t frame_lock

Definition: avfoundation.m:90

av_rescale_q

int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)

Rescale a 64-bit integer by 2 rational numbers.

Definition: mathematics.c:142

AVFContext::capture_raw_data

int capture_raw_data

Definition: avfoundation.m:99

AVFContext::list_devices

int list_devices

Definition: avfoundation.m:104

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

AVFPixelFormatSpec

Definition: avfoundation.m:50

get_video_config

static int get_video_config(AVFormatContext *s)

Definition: avfoundation.m:630

if(ret)

Definition: filter_design.txt:179

AVFContext::audio_packed

int audio_packed

Definition: avfoundation.m:121

AVFFrameReceiver::_context

AVFContext * _context

Definition: avfoundation.m:156

context

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 default minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your context

Definition: writing_filters.txt:91

AVFormatContext

Format I/O context.

Definition: avformat.h:1255

internal.h

AVFContext::video_output

AVCaptureVideoDataOutput * video_output

Definition: avfoundation.m:130

framerate

float framerate

Definition: av1_levels.c:29

AVFContext::audio_signed_integer

int audio_signed_integer

Definition: avfoundation.m:120

AV_PIX_FMT_RGB565LE

@ AV_PIX_FMT_RGB565LE

packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian

Definition: pixfmt.h:113

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

read_header

static int read_header(FFV1Context *f)

Definition: ffv1dec.c:550

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:66

fabs

static __device__ float fabs(float a)

Definition: cuda_runtime.h:182

NULL

#define NULL

Definition: coverity.c:32

AVFContext::drop_late_frames

int drop_late_frames

Definition: avfoundation.m:100

AV_PIX_FMT_YUYV422

@ AV_PIX_FMT_YUYV422

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

Definition: pixfmt.h:74

add_video_device

static int add_video_device(AVFormatContext *s, AVCaptureDevice *video_device)

Definition: avfoundation.m:439

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

AVFFrameReceiver

FrameReciever class - delegate for AVCaptureSession.

Definition: avfoundation.m:154

ff_avfoundation_demuxer

const FFInputFormat ff_avfoundation_demuxer

Definition: avfoundation.m:1299

AV_PIX_FMT_MONOBLACK

@ AV_PIX_FMT_MONOBLACK

Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb.

Definition: pixfmt.h:83

AV_OPT_TYPE_IMAGE_SIZE

@ AV_OPT_TYPE_IMAGE_SIZE

offset must point to two consecutive integers

Definition: opt.h:245

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:237

parseutils.h

AV_PIX_FMT_BGR0

@ AV_PIX_FMT_BGR0

packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined

Definition: pixfmt.h:265

time.h

AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT

@ AV_CLASS_CATEGORY_DEVICE_VIDEO_INPUT

Definition: log.h:41

AV_PIX_FMT_YUV422P10

#define AV_PIX_FMT_YUV422P10

Definition: pixfmt.h:479

AV_PIX_FMT_GRAY8

@ AV_PIX_FMT_GRAY8

Y , 8bpp.

Definition: pixfmt.h:81

avf_read_packet

static int avf_read_packet(AVFormatContext *s, AVPacket *pkt)

Definition: avfoundation.m:1118

AVFContext::width

int width

Definition: avfoundation.m:95

configure_video_device

static int configure_video_device(AVFormatContext *s, AVCaptureDevice *video_device)

Configure the video device.

Definition: avfoundation.m:342

index

int index

Definition: gxfenc.c:89

Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c

Definition: undefined.txt:32

pthread_mutex_unlock

#define pthread_mutex_unlock(a)

Definition: ffprobe.c:81

AVFContext::audio_buffer

int32_t * audio_buffer

Definition: avfoundation.m:124

AVFContext::video_stream_index

int video_stream_index

Definition: avfoundation.m:106

AV_CODEC_ID_PCM_S24LE

@ AV_CODEC_ID_PCM_S24LE

Definition: codec_id.h:340

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts.c:365

AV_PIX_FMT_RGB24

@ AV_PIX_FMT_RGB24

packed RGB 8:8:8, 24bpp, RGBRGB...

Definition: pixfmt.h:75

AVMediaType

Definition: avutil.h:199

AVPacket::size

int size

Definition: packet.h:523

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.

Definition: internal.h:106

destroy_context

static void destroy_context(AVFContext *ctx)

Definition: avfoundation.m:288

shift

static int shift(int a, int b)

Definition: bonk.c:262

AVFContext::url

char * url

Definition: avfoundation.m:110

AVFormatContext::url

char * url

input or output URL.

Definition: avformat.h:1371

sample

#define sample

Definition: flacdsp_template.c:44

av_make_q

static AVRational av_make_q(int num, int den)

Create an AVRational.

Definition: rational.h:71

AVFMT_NOFILE

#define AVFMT_NOFILE

Demuxer will use avio_open, no opened file should be provided by the caller.

Definition: avformat.h:468

AVFContext::audio_non_interleaved

int audio_non_interleaved

Definition: avfoundation.m:122

range

enum AVColorRange range

Definition: mediacodec_wrapper.c:2557

avdevice.h

FFInputFormat::p

AVInputFormat p

The public AVInputFormat.

Definition: demux.h:41

AVPacket::dts

int64_t dts

Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.

Definition: packet.h:521

height

#define height

AV_PIX_FMT_YUVA444P

@ AV_PIX_FMT_YUVA444P

planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)

Definition: pixfmt.h:174

AVERROR_EXTERNAL

#define AVERROR_EXTERNAL

Generic error in an external library.

Definition: error.h:59

AVPacket::flags

int flags

A combination of AV_PKT_FLAG values.

Definition: packet.h:528

AV_PIX_FMT_RGB0

@ AV_PIX_FMT_RGB0

packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined

Definition: pixfmt.h:263

AV_LOG_INFO

#define AV_LOG_INFO

Standard information.

Definition: log.h:191

pthread_mutex_destroy

static av_always_inline int pthread_mutex_destroy(pthread_mutex_t *mutex)

Definition: os2threads.h:112

av_channel_layout_default

void av_channel_layout_default(AVChannelLayout *ch_layout, int nb_channels)

Get the default channel layout for a given number of channels.

Definition: channel_layout.c:830

lock_frames

static void lock_frames(AVFContext *ctx)

Definition: avfoundation.m:142

AVFContext::audio_stream_index

int audio_stream_index

Definition: avfoundation.m:108

copy_cvpixelbuffer

static int copy_cvpixelbuffer(AVFormatContext *s, CVPixelBufferRef image_buffer, AVPacket *pkt)

Definition: avfoundation.m:1075

AV_PIX_FMT_RGB555LE

@ AV_PIX_FMT_RGB555LE

packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined

Definition: pixfmt.h:115

AVFContext::audio_bits_per_sample

int audio_bits_per_sample

Definition: avfoundation.m:117

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

Definition: cbs_h2645.c:255

AVPacket::pts

int64_t pts

Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...

Definition: packet.h:515

avf_read_header

static int avf_read_header(AVFormatContext *s)

Definition: avfoundation.m:823

internal.h

AV_CODEC_ID_DVVIDEO

@ AV_CODEC_ID_DVVIDEO

Definition: codec_id.h:76

AV_CODEC_ID_PCM_S32BE

@ AV_CODEC_ID_PCM_S32BE

Definition: codec_id.h:337

demux.h

AVFContext::frames_captured

int frames_captured

Definition: avfoundation.m:88

AVFContext::video_is_muxed

int video_is_muxed

Definition: avfoundation.m:101

ret

Definition: filter_design.txt:187

AVStream

Stream structure.

Definition: avformat.h:743

AV_PIX_FMT_0BGR

@ AV_PIX_FMT_0BGR

packed BGR 8:8:8, 32bpp, XBGRXBGR... X=unused/undefined

Definition: pixfmt.h:264

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

AVFContext::audio_device_index

int audio_device_index

Definition: avfoundation.m:107

AVClass::class_name

const char * class_name

The name of the class; usually it is the same name as the context structure type to which the AVClass...

Definition: log.h:71

avf_pixel_formats

static const struct AVFPixelFormatSpec avf_pixel_formats[]

Definition: avfoundation.m:55

AVFContext::audio_output

AVCaptureAudioDataOutput * audio_output

Definition: avfoundation.m:131

enum AVCodecID id

Definition: dts2pts.c:364

AV_PIX_FMT_UYVY422

@ AV_PIX_FMT_UYVY422

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

Definition: pixfmt.h:88

status

ov_status_e status

Definition: dnn_backend_openvino.c:120

AVFContext::avf_audio_delegate

id avf_audio_delegate

Definition: avfoundation.m:92

channel_layout.h

AVFContext::video_is_screen

int video_is_screen

Definition: avfoundation.m:102

mode

Definition: ebur128.h:83

AV_PIX_FMT_NONE

@ AV_PIX_FMT_NONE

Definition: pixfmt.h:72

AV_OPT_TYPE_INT

@ AV_OPT_TYPE_INT

Definition: opt.h:235

AV_OPT_TYPE_PIXEL_FMT

@ AV_OPT_TYPE_PIXEL_FMT

Definition: opt.h:246

AVPacket::stream_index

int stream_index

Definition: packet.h:524

AV_PIX_FMT_YUV444P

@ AV_PIX_FMT_YUV444P

planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)

Definition: pixfmt.h:78

AVFContext::audio_filename

char * audio_filename

Definition: avfoundation.m:112

AV_PIX_FMT_RGB565BE

@ AV_PIX_FMT_RGB565BE

packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), big-endian

Definition: pixfmt.h:112

av_strdup

char * av_strdup(const char *s)

Duplicate a string.

Definition: mem.c:270

AV_OPT_FLAG_DECODING_PARAM

#define AV_OPT_FLAG_DECODING_PARAM

A generic parameter which can be set by the user for demuxing or decoding.

Definition: opt.h:273

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

AV_CODEC_ID_PCM_S32LE

@ AV_CODEC_ID_PCM_S32LE

Definition: codec_id.h:336

get_audio_config

static int get_audio_config(AVFormatContext *s)

Definition: avfoundation.m:678

AVFContext

Definition: avfoundation.m:84

timing_info

static int FUNC() timing_info(CodedBitstreamContext *ctx, RWContext *rw, AV1RawTimingInfo *current)

Definition: cbs_av1_syntax_template.c:158

av_image_copy_to_buffer

int av_image_copy_to_buffer(uint8_t *dst, int dst_size, const uint8_t *const src_data[4], const int src_linesize[4], enum AVPixelFormat pix_fmt, int width, int height, int align)

Copy image data from an image into a buffer.

Definition: imgutils.c:501

AVPacket

This structure stores compressed data.

Definition: packet.h:499

AV_OPT_TYPE_BOOL

@ AV_OPT_TYPE_BOOL

Definition: opt.h:251

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:34

FFInputFormat