FFmpeg: libavcodec/pthread_frame.c Source File

FFmpeg

[フレーム]

libavcodec

pthread_frame.c

Go to the documentation of this file.

1 /*

2 * This file is part of FFmpeg.

3 *

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

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

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

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

8 *

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

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

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

12 * Lesser General Public License for more details.

13 *

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

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

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

17 */

19 /**

20 * @file

21 * Frame multithreading support functions

22 * @see doc/multithreading.txt

23 */

25 #include "config.h"

27 #include <stdatomic.h>

28 #include <stdint.h>

30 #include "avcodec.h"

31 #include "hwaccel.h"

32 #include "internal.h"

33 #include "pthread_internal.h"

34 #include "thread.h"

35 #include "version.h"

37 #include "libavutil/avassert.h"

38 #include "libavutil/buffer.h"

39 #include "libavutil/common.h"

40 #include "libavutil/cpu.h"

41 #include "libavutil/frame.h"

42 #include "libavutil/internal.h"

43 #include "libavutil/log.h"

44 #include "libavutil/mem.h"

45 #include "libavutil/opt.h"

46 #include "libavutil/thread.h"

48 enum {

49 ///< Set when the thread is awaiting a packet.

50 STATE_INPUT_READY,

51 ///< Set before the codec has called ff_thread_finish_setup().

52 STATE_SETTING_UP,

53 /**

54 * Set when the codec calls get_buffer().

55 * State is returned to STATE_SETTING_UP afterwards.

56 */

57 STATE_GET_BUFFER,

58 /**

59 * Set when the codec calls get_format().

60 * State is returned to STATE_SETTING_UP afterwards.

61 */

62 STATE_GET_FORMAT,

63 ///< Set after the codec has called ff_thread_finish_setup().

64 STATE_SETUP_FINISHED,

65 };

67 /**

68 * Context used by codec threads and stored in their AVCodecInternal thread_ctx.

69 */

70 typedef struct PerThreadContext {

71 struct FrameThreadContext *parent;

73 pthread_t thread;

74 int thread_init;

75 pthread_cond_t input_cond; ///< Used to wait for a new packet from the main thread.

76 pthread_cond_t progress_cond; ///< Used by child threads to wait for progress to change.

77 pthread_cond_t output_cond; ///< Used by the main thread to wait for frames to finish.

79 pthread_mutex_t mutex; ///< Mutex used to protect the contents of the PerThreadContext.

80 pthread_mutex_t progress_mutex; ///< Mutex used to protect frame progress values and progress_cond.

82 AVCodecContext *avctx; ///< Context used to decode packets passed to this thread.

84 AVPacket avpkt; ///< Input packet (for decoding) or output (for encoding).

86 AVFrame *frame; ///< Output frame (for decoding) or input (for encoding).

87 int got_frame; ///< The output of got_picture_ptr from the last avcodec_decode_video() call.

88 int result; ///< The result of the last codec decode/encode() call.

90 atomic_int state;

92 /**

93 * Array of frames passed to ff_thread_release_buffer().

94 * Frames are released after all threads referencing them are finished.

95 */

96 AVFrame *released_buffers;

97 int num_released_buffers;

98 int released_buffers_allocated;

100 AVFrame *requested_frame; ///< AVFrame the codec passed to get_buffer()

101 int requested_flags; ///< flags passed to get_buffer() for requested_frame

102

103 const enum AVPixelFormat *available_formats; ///< Format array for get_format()

104 enum AVPixelFormat result_format; ///< get_format() result

105

106 int die; ///< Set when the thread should exit.

107

108 int hwaccel_serializing;

109 int async_serializing;

110

111 atomic_int debug_threads; ///< Set if the FF_DEBUG_THREADS option is set.

112 } PerThreadContext;

113

114 /**

115 * Context stored in the client AVCodecInternal thread_ctx.

116 */

117 typedef struct FrameThreadContext {

118 PerThreadContext *threads; ///< The contexts for each thread.

119 PerThreadContext *prev_thread; ///< The last thread submit_packet() was called on.

120

121 pthread_mutex_t buffer_mutex; ///< Mutex used to protect get/release_buffer().

122 /**

123 * This lock is used for ensuring threads run in serial when hwaccel

124 * is used.

125 */

126 pthread_mutex_t hwaccel_mutex;

127 pthread_mutex_t async_mutex;

128 pthread_cond_t async_cond;

129 int async_lock;

130

131 int next_decoding; ///< The next context to submit a packet to.

132 int next_finished; ///< The next context to return output from.

133

134 int delaying; /**<

135 * Set for the first N packets, where N is the number of threads.

136 * While it is set, ff_thread_en/decode_frame won't return any results.

137 */

138 } FrameThreadContext;

139

140 #define THREAD_SAFE_CALLBACKS(avctx) \

141 ((avctx)->thread_safe_callbacks || (avctx)->get_buffer2 == avcodec_default_get_buffer2)

142

143 static void async_lock(FrameThreadContext *fctx)

144 {

145 pthread_mutex_lock(&fctx->async_mutex);

146 while (fctx->async_lock)

147 pthread_cond_wait(&fctx->async_cond, &fctx->async_mutex);

148 fctx->async_lock = 1;

149 pthread_mutex_unlock(&fctx->async_mutex);

150 }

151

152 static void async_unlock(FrameThreadContext *fctx)

153 {

154 pthread_mutex_lock(&fctx->async_mutex);

155 av_assert0(fctx->async_lock);

156 fctx->async_lock = 0;

157 pthread_cond_broadcast(&fctx->async_cond);

158 pthread_mutex_unlock(&fctx->async_mutex);

159 }

160

161 /**

162 * Codec worker thread.

163 *

164 * Automatically calls ff_thread_finish_setup() if the codec does

165 * not provide an update_thread_context method, or if the codec returns

166 * before calling it.

167 */

168 static attribute_align_arg void *frame_worker_thread(void *arg)

169 {

170 PerThreadContext *p = arg;

171 AVCodecContext *avctx = p->avctx;

172 const AVCodec *codec = avctx->codec;

173

174 pthread_mutex_lock(&p->mutex);

175 while (1) {

176 while (atomic_load(&p->state) == STATE_INPUT_READY && !p->die)

177 pthread_cond_wait(&p->input_cond, &p->mutex);

178

179 if (p->die) break;

180

181 if (!codec->update_thread_context && THREAD_SAFE_CALLBACKS(avctx))

182 ff_thread_finish_setup(avctx);

183

184 /* If a decoder supports hwaccel, then it must call ff_get_format().

185 * Since that call must happen before ff_thread_finish_setup(), the

186 * decoder is required to implement update_thread_context() and call

187 * ff_thread_finish_setup() manually. Therefore the above

188 * ff_thread_finish_setup() call did not happen and hwaccel_serializing

189 * cannot be true here. */

190 av_assert0(!p->hwaccel_serializing);

191

192 /* if the previous thread uses hwaccel then we take the lock to ensure

193 * the threads don't run concurrently */

194 if (avctx->hwaccel) {

195 pthread_mutex_lock(&p->parent->hwaccel_mutex);

196 p->hwaccel_serializing = 1;

197 }

198

199 av_frame_unref(p->frame);

200 p->got_frame = 0;

201 p->result = codec->decode(avctx, p->frame, &p->got_frame, &p->avpkt);

202

203 if ((p->result < 0 || !p->got_frame) && p->frame->buf[0]) {

204 if (avctx->internal->allocate_progress)

205 av_log(avctx, AV_LOG_ERROR, "A frame threaded decoder did not "

206 "free the frame on failure. This is a bug, please report it.\n");

207 av_frame_unref(p->frame);

208 }

209

210 if (atomic_load(&p->state) == STATE_SETTING_UP)

211 ff_thread_finish_setup(avctx);

212

213 if (p->hwaccel_serializing) {

214 p->hwaccel_serializing = 0;

215 pthread_mutex_unlock(&p->parent->hwaccel_mutex);

216 }

217

218 if (p->async_serializing) {

219 p->async_serializing = 0;

220

221 async_unlock(p->parent);

222 }

223

224 pthread_mutex_lock(&p->progress_mutex);

225

226 atomic_store(&p->state, STATE_INPUT_READY);

227

228 pthread_cond_broadcast(&p->progress_cond);

229 pthread_cond_signal(&p->output_cond);

230 pthread_mutex_unlock(&p->progress_mutex);

231 }

232 pthread_mutex_unlock(&p->mutex);

233

234 return NULL;

235 }

236

237 /**

238 * Update the next thread's AVCodecContext with values from the reference thread's context.

239 *

240 * @param dst The destination context.

241 * @param src The source context.

242 * @param for_user 0 if the destination is a codec thread, 1 if the destination is the user's thread

243 * @return 0 on success, negative error code on failure

244 */

245 static int update_context_from_thread(AVCodecContext *dst, AVCodecContext *src, int for_user)

246 {

247 int err = 0;

248

249 if (dst != src && (for_user || !(src->codec_descriptor->props & AV_CODEC_PROP_INTRA_ONLY))) {

250 dst->time_base = src->time_base;

251 dst->framerate = src->framerate;

252 dst->width = src->width;

253 dst->height = src->height;

254 dst->pix_fmt = src->pix_fmt;

255 dst->sw_pix_fmt = src->sw_pix_fmt;

256

257 dst->coded_width = src->coded_width;

258 dst->coded_height = src->coded_height;

259

260 dst->has_b_frames = src->has_b_frames;

261 dst->idct_algo = src->idct_algo;

262

263 dst->bits_per_coded_sample = src->bits_per_coded_sample;

264 dst->sample_aspect_ratio = src->sample_aspect_ratio;

265

266 dst->profile = src->profile;

267 dst->level = src->level;

268

269 dst->bits_per_raw_sample = src->bits_per_raw_sample;

270 dst->ticks_per_frame = src->ticks_per_frame;

271 dst->color_primaries = src->color_primaries;

272

273 dst->color_trc = src->color_trc;

274 dst->colorspace = src->colorspace;

275 dst->color_range = src->color_range;

276 dst->chroma_sample_location = src->chroma_sample_location;

277

278 dst->hwaccel = src->hwaccel;

279 dst->hwaccel_context = src->hwaccel_context;

280

281 dst->channels = src->channels;

282 dst->sample_rate = src->sample_rate;

283 dst->sample_fmt = src->sample_fmt;

284 dst->channel_layout = src->channel_layout;

285 dst->internal->hwaccel_priv_data = src->internal->hwaccel_priv_data;

286

287 if (!!dst->hw_frames_ctx != !!src->hw_frames_ctx ||

288 (dst->hw_frames_ctx && dst->hw_frames_ctx->data != src->hw_frames_ctx->data)) {

289 av_buffer_unref(&dst->hw_frames_ctx);

290

291 if (src->hw_frames_ctx) {

292 dst->hw_frames_ctx = av_buffer_ref(src->hw_frames_ctx);

293 if (!dst->hw_frames_ctx)

294 return AVERROR(ENOMEM);

295 }

296 }

297

298 dst->hwaccel_flags = src->hwaccel_flags;

299 }

300

301 if (for_user) {

302 dst->delay = src->thread_count - 1;

303 #if FF_API_CODED_FRAME

304 FF_DISABLE_DEPRECATION_WARNINGS

305 dst->coded_frame = src->coded_frame;

306 FF_ENABLE_DEPRECATION_WARNINGS

307 #endif

308 } else {

309 if (dst->codec->update_thread_context)

310 err = dst->codec->update_thread_context(dst, src);

311 }

312

313 return err;

314 }

315

316 /**

317 * Update the next thread's AVCodecContext with values set by the user.

318 *

319 * @param dst The destination context.

320 * @param src The source context.

321 * @return 0 on success, negative error code on failure

322 */

323 static int update_context_from_user(AVCodecContext *dst, AVCodecContext *src)

324 {

325 #define copy_fields(s, e) memcpy(&dst->s, &src->s, (char*)&dst->e - (char*)&dst->s);

326 dst->flags = src->flags;

327

328 dst->draw_horiz_band= src->draw_horiz_band;

329 dst->get_buffer2 = src->get_buffer2;

330

331 dst->opaque = src->opaque;

332 dst->debug = src->debug;

333 dst->debug_mv = src->debug_mv;

334

335 dst->slice_flags = src->slice_flags;

336 dst->flags2 = src->flags2;

337

338 copy_fields(skip_loop_filter, subtitle_header);

339

340 dst->frame_number = src->frame_number;

341 dst->reordered_opaque = src->reordered_opaque;

342 dst->thread_safe_callbacks = src->thread_safe_callbacks;

343

344 if (src->slice_count && src->slice_offset) {

345 if (dst->slice_count < src->slice_count) {

346 int err = av_reallocp_array(&dst->slice_offset, src->slice_count,

347 sizeof(*dst->slice_offset));

348 if (err < 0)

349 return err;

350 }

351 memcpy(dst->slice_offset, src->slice_offset,

352 src->slice_count * sizeof(*dst->slice_offset));

353 }

354 dst->slice_count = src->slice_count;

355 return 0;

356 #undef copy_fields

357 }

358

359 /// Releases the buffers that this decoding thread was the last user of.

360 static void release_delayed_buffers(PerThreadContext *p)

361 {

362 FrameThreadContext *fctx = p->parent;

363

364 while (p->num_released_buffers > 0) {

365 AVFrame *f;

366

367 pthread_mutex_lock(&fctx->buffer_mutex);

368

369 // fix extended data in case the caller screwed it up

370 av_assert0(p->avctx->codec_type == AVMEDIA_TYPE_VIDEO ||

371 p->avctx->codec_type == AVMEDIA_TYPE_AUDIO);

372 f = &p->released_buffers[--p->num_released_buffers];

373 f->extended_data = f->data;

374 av_frame_unref(f);

375

376 pthread_mutex_unlock(&fctx->buffer_mutex);

377 }

378 }

379

380 static int submit_packet(PerThreadContext *p, AVCodecContext *user_avctx,

381 AVPacket *avpkt)

382 {

383 FrameThreadContext *fctx = p->parent;

384 PerThreadContext *prev_thread = fctx->prev_thread;

385 const AVCodec *codec = p->avctx->codec;

386 int ret;

387

388 if (!avpkt->size && !(codec->capabilities & AV_CODEC_CAP_DELAY))

389 return 0;

390

391 pthread_mutex_lock(&p->mutex);

392

393 ret = update_context_from_user(p->avctx, user_avctx);

394 if (ret) {

395 pthread_mutex_unlock(&p->mutex);

396 return ret;

397 }

398 atomic_store_explicit(&p->debug_threads,

399 (p->avctx->debug & FF_DEBUG_THREADS) != 0,

400 memory_order_relaxed);

401

402 release_delayed_buffers(p);

403

404 if (prev_thread) {

405 int err;

406 if (atomic_load(&prev_thread->state) == STATE_SETTING_UP) {

407 pthread_mutex_lock(&prev_thread->progress_mutex);

408 while (atomic_load(&prev_thread->state) == STATE_SETTING_UP)

409 pthread_cond_wait(&prev_thread->progress_cond, &prev_thread->progress_mutex);

410 pthread_mutex_unlock(&prev_thread->progress_mutex);

411 }

412

413 err = update_context_from_thread(p->avctx, prev_thread->avctx, 0);

414 if (err) {

415 pthread_mutex_unlock(&p->mutex);

416 return err;

417 }

418 }

419

420 av_packet_unref(&p->avpkt);

421 ret = av_packet_ref(&p->avpkt, avpkt);

422 if (ret < 0) {

423 pthread_mutex_unlock(&p->mutex);

424 av_log(p->avctx, AV_LOG_ERROR, "av_packet_ref() failed in submit_packet()\n");

425 return ret;

426 }

427

428 atomic_store(&p->state, STATE_SETTING_UP);

429 pthread_cond_signal(&p->input_cond);

430 pthread_mutex_unlock(&p->mutex);

431

432 /*

433 * If the client doesn't have a thread-safe get_buffer(),

434 * then decoding threads call back to the main thread,

435 * and it calls back to the client here.

436 */

437

438 if (!p->avctx->thread_safe_callbacks && (

439 p->avctx->get_format != avcodec_default_get_format ||

440 p->avctx->get_buffer2 != avcodec_default_get_buffer2)) {

441 while (atomic_load(&p->state) != STATE_SETUP_FINISHED && atomic_load(&p->state) != STATE_INPUT_READY) {

442 int call_done = 1;

443 pthread_mutex_lock(&p->progress_mutex);

444 while (atomic_load(&p->state) == STATE_SETTING_UP)

445 pthread_cond_wait(&p->progress_cond, &p->progress_mutex);

446

447 switch (atomic_load_explicit(&p->state, memory_order_acquire)) {

448 case STATE_GET_BUFFER:

449 p->result = ff_get_buffer(p->avctx, p->requested_frame, p->requested_flags);

450 break;

451 case STATE_GET_FORMAT:

452 p->result_format = ff_get_format(p->avctx, p->available_formats);

453 break;

454 default:

455 call_done = 0;

456 break;

457 }

458 if (call_done) {

459 atomic_store(&p->state, STATE_SETTING_UP);

460 pthread_cond_signal(&p->progress_cond);

461 }

462 pthread_mutex_unlock(&p->progress_mutex);

463 }

464 }

465

466 fctx->prev_thread = p;

467 fctx->next_decoding++;

468

469 return 0;

470 }

471

472 int ff_thread_decode_frame(AVCodecContext *avctx,

473 AVFrame *picture, int *got_picture_ptr,

474 AVPacket *avpkt)

475 {

476 FrameThreadContext *fctx = avctx->internal->thread_ctx;

477 int finished = fctx->next_finished;

478 PerThreadContext *p;

479 int err;

480

481 /* release the async lock, permitting blocked hwaccel threads to

482 * go forward while we are in this function */

483 async_unlock(fctx);

484

485 /*

486 * Submit a packet to the next decoding thread.

487 */

488

489 p = &fctx->threads[fctx->next_decoding];

490 err = submit_packet(p, avctx, avpkt);

491 if (err)

492 goto finish;

493

494 /*

495 * If we're still receiving the initial packets, don't return a frame.

496 */

497

498 if (fctx->next_decoding > (avctx->thread_count-1-(avctx->codec_id == AV_CODEC_ID_FFV1)))

499 fctx->delaying = 0;

500

501 if (fctx->delaying) {

502 *got_picture_ptr=0;

503 if (avpkt->size) {

504 err = avpkt->size;

505 goto finish;

506 }

507 }

508

509 /*

510 * Return the next available frame from the oldest thread.

511 * If we're at the end of the stream, then we have to skip threads that

512 * didn't output a frame/error, because we don't want to accidentally signal

513 * EOF (avpkt->size == 0 && *got_picture_ptr == 0 && err >= 0).

514 */

515

516 do {

517 p = &fctx->threads[finished++];

518

519 if (atomic_load(&p->state) != STATE_INPUT_READY) {

520 pthread_mutex_lock(&p->progress_mutex);

521 while (atomic_load_explicit(&p->state, memory_order_relaxed) != STATE_INPUT_READY)

522 pthread_cond_wait(&p->output_cond, &p->progress_mutex);

523 pthread_mutex_unlock(&p->progress_mutex);

524 }

525

526 av_frame_move_ref(picture, p->frame);

527 *got_picture_ptr = p->got_frame;

528 picture->pkt_dts = p->avpkt.dts;

529 err = p->result;

530

531 /*

532 * A later call with avkpt->size == 0 may loop over all threads,

533 * including this one, searching for a frame/error to return before being

534 * stopped by the "finished != fctx->next_finished" condition.

535 * Make sure we don't mistakenly return the same frame/error again.

536 */

537 p->got_frame = 0;

538 p->result = 0;

539

540 if (finished >= avctx->thread_count) finished = 0;

541 } while (!avpkt->size && !*got_picture_ptr && err >= 0 && finished != fctx->next_finished);

542

543 update_context_from_thread(avctx, p->avctx, 1);

544

545 if (fctx->next_decoding >= avctx->thread_count) fctx->next_decoding = 0;

546

547 fctx->next_finished = finished;

548

549 /* return the size of the consumed packet if no error occurred */

550 if (err >= 0)

551 err = avpkt->size;

552 finish:

553 async_lock(fctx);

554 return err;

555 }

556

557 void ff_thread_report_progress(ThreadFrame *f, int n, int field)

558 {

559 PerThreadContext *p;

560 atomic_int *progress = f->progress ? (atomic_int*)f->progress->data : NULL;

561

562 if (!progress ||

563 atomic_load_explicit(&progress[field], memory_order_relaxed) >= n)

564 return;

565

566 p = f->owner[field]->internal->thread_ctx;

567

568 if (atomic_load_explicit(&p->debug_threads, memory_order_relaxed))

569 av_log(f->owner[field], AV_LOG_DEBUG,

570 "%p finished %d field %d\n", progress, n, field);

571

572 pthread_mutex_lock(&p->progress_mutex);

573

574 atomic_store_explicit(&progress[field], n, memory_order_release);

575

576 pthread_cond_broadcast(&p->progress_cond);

577 pthread_mutex_unlock(&p->progress_mutex);

578 }

579

580 void ff_thread_await_progress(ThreadFrame *f, int n, int field)

581 {

582 PerThreadContext *p;

583 atomic_int *progress = f->progress ? (atomic_int*)f->progress->data : NULL;

584

585 if (!progress ||

586 atomic_load_explicit(&progress[field], memory_order_acquire) >= n)

587 return;

588

589 p = f->owner[field]->internal->thread_ctx;

590

591 if (atomic_load_explicit(&p->debug_threads, memory_order_relaxed))

592 av_log(f->owner[field], AV_LOG_DEBUG,

593 "thread awaiting %d field %d from %p\n", n, field, progress);

594

595 pthread_mutex_lock(&p->progress_mutex);

596 while (atomic_load_explicit(&progress[field], memory_order_relaxed) < n)

597 pthread_cond_wait(&p->progress_cond, &p->progress_mutex);

598 pthread_mutex_unlock(&p->progress_mutex);

599 }

600

601 void ff_thread_finish_setup(AVCodecContext *avctx) {

602 PerThreadContext *p = avctx->internal->thread_ctx;

603

604 if (!(avctx->active_thread_type&FF_THREAD_FRAME)) return;

605

606 if (avctx->hwaccel && !p->hwaccel_serializing) {

607 pthread_mutex_lock(&p->parent->hwaccel_mutex);

608 p->hwaccel_serializing = 1;

609 }

610

611 /* this assumes that no hwaccel calls happen before ff_thread_finish_setup() */

612 if (avctx->hwaccel &&

613 !(avctx->hwaccel->caps_internal & HWACCEL_CAP_ASYNC_SAFE)) {

614 p->async_serializing = 1;

615

616 async_lock(p->parent);

617 }

618

619 pthread_mutex_lock(&p->progress_mutex);

620 if(atomic_load(&p->state) == STATE_SETUP_FINISHED){

621 av_log(avctx, AV_LOG_WARNING, "Multiple ff_thread_finish_setup() calls\n");

622 }

623

624 atomic_store(&p->state, STATE_SETUP_FINISHED);

625

626 pthread_cond_broadcast(&p->progress_cond);

627 pthread_mutex_unlock(&p->progress_mutex);

628 }

629

630 /// Waits for all threads to finish.

631 static void park_frame_worker_threads(FrameThreadContext *fctx, int thread_count)

632 {

633 int i;

634

635 async_unlock(fctx);

636

637 for (i = 0; i < thread_count; i++) {

638 PerThreadContext *p = &fctx->threads[i];

639

640 if (atomic_load(&p->state) != STATE_INPUT_READY) {

641 pthread_mutex_lock(&p->progress_mutex);

642 while (atomic_load(&p->state) != STATE_INPUT_READY)

643 pthread_cond_wait(&p->output_cond, &p->progress_mutex);

644 pthread_mutex_unlock(&p->progress_mutex);

645 }

646 p->got_frame = 0;

647 }

648

649 async_lock(fctx);

650 }

651

652 void ff_frame_thread_free(AVCodecContext *avctx, int thread_count)

653 {

654 FrameThreadContext *fctx = avctx->internal->thread_ctx;

655 const AVCodec *codec = avctx->codec;

656 int i;

657

658 park_frame_worker_threads(fctx, thread_count);

659

660 if (fctx->prev_thread && fctx->prev_thread != fctx->threads)

661 if (update_context_from_thread(fctx->threads->avctx, fctx->prev_thread->avctx, 0) < 0) {

662 av_log(avctx, AV_LOG_ERROR, "Final thread update failed\n");

663 fctx->prev_thread->avctx->internal->is_copy = fctx->threads->avctx->internal->is_copy;

664 fctx->threads->avctx->internal->is_copy = 1;

665 }

666

667 for (i = 0; i < thread_count; i++) {

668 PerThreadContext *p = &fctx->threads[i];

669

670 pthread_mutex_lock(&p->mutex);

671 p->die = 1;

672 pthread_cond_signal(&p->input_cond);

673 pthread_mutex_unlock(&p->mutex);

674

675 if (p->thread_init)

676 pthread_join(p->thread, NULL);

677 p->thread_init=0;

678

679 if (codec->close && p->avctx)

680 codec->close(p->avctx);

681

682 release_delayed_buffers(p);

683 av_frame_free(&p->frame);

684 }

685

686 for (i = 0; i < thread_count; i++) {

687 PerThreadContext *p = &fctx->threads[i];

688

689 pthread_mutex_destroy(&p->mutex);

690 pthread_mutex_destroy(&p->progress_mutex);

691 pthread_cond_destroy(&p->input_cond);

692 pthread_cond_destroy(&p->progress_cond);

693 pthread_cond_destroy(&p->output_cond);

694 av_packet_unref(&p->avpkt);

695 av_freep(&p->released_buffers);

696

697 if (i && p->avctx) {

698 av_freep(&p->avctx->priv_data);

699 av_freep(&p->avctx->slice_offset);

700 }

701

702 if (p->avctx) {

703 av_freep(&p->avctx->internal);

704 av_buffer_unref(&p->avctx->hw_frames_ctx);

705 }

706

707 av_freep(&p->avctx);

708 }

709

710 av_freep(&fctx->threads);

711 pthread_mutex_destroy(&fctx->buffer_mutex);

712 pthread_mutex_destroy(&fctx->hwaccel_mutex);

713 pthread_mutex_destroy(&fctx->async_mutex);

714 pthread_cond_destroy(&fctx->async_cond);

715

716 av_freep(&avctx->internal->thread_ctx);

717

718 if (avctx->priv_data && avctx->codec && avctx->codec->priv_class)

719 av_opt_free(avctx->priv_data);

720 avctx->codec = NULL;

721 }

722

723 int ff_frame_thread_init(AVCodecContext *avctx)

724 {

725 int thread_count = avctx->thread_count;

726 const AVCodec *codec = avctx->codec;

727 AVCodecContext *src = avctx;

728 FrameThreadContext *fctx;

729 int i, err = 0;

730

731 if (!thread_count) {

732 int nb_cpus = av_cpu_count();

733 #if FF_API_DEBUG_MV

734 if ((avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) || avctx->debug_mv)

735 nb_cpus = 1;

736 #endif

737 // use number of cores + 1 as thread count if there is more than one

738 if (nb_cpus > 1)

739 thread_count = avctx->thread_count = FFMIN(nb_cpus + 1, MAX_AUTO_THREADS);

740 else

741 thread_count = avctx->thread_count = 1;

742 }

743

744 if (thread_count <= 1) {

745 avctx->active_thread_type = 0;

746 return 0;

747 }

748

749 avctx->internal->thread_ctx = fctx = av_mallocz(sizeof(FrameThreadContext));

750 if (!fctx)

751 return AVERROR(ENOMEM);

752

753 fctx->threads = av_mallocz_array(thread_count, sizeof(PerThreadContext));

754 if (!fctx->threads) {

755 av_freep(&avctx->internal->thread_ctx);

756 return AVERROR(ENOMEM);

757 }

758

759 pthread_mutex_init(&fctx->buffer_mutex, NULL);

760 pthread_mutex_init(&fctx->hwaccel_mutex, NULL);

761 pthread_mutex_init(&fctx->async_mutex, NULL);

762 pthread_cond_init(&fctx->async_cond, NULL);

763

764 fctx->async_lock = 1;

765 fctx->delaying = 1;

766

767 for (i = 0; i < thread_count; i++) {

768 AVCodecContext *copy = av_malloc(sizeof(AVCodecContext));

769 PerThreadContext *p = &fctx->threads[i];

770

771 pthread_mutex_init(&p->mutex, NULL);

772 pthread_mutex_init(&p->progress_mutex, NULL);

773 pthread_cond_init(&p->input_cond, NULL);

774 pthread_cond_init(&p->progress_cond, NULL);

775 pthread_cond_init(&p->output_cond, NULL);

776

777 p->frame = av_frame_alloc();

778 if (!p->frame) {

779 av_freep(&copy);

780 err = AVERROR(ENOMEM);

781 goto error;

782 }

783

784 p->parent = fctx;

785 p->avctx = copy;

786

787 if (!copy) {

788 err = AVERROR(ENOMEM);

789 goto error;

790 }

791

792 *copy = *src;

793

794 copy->internal = av_malloc(sizeof(AVCodecInternal));

795 if (!copy->internal) {

796 copy->priv_data = NULL;

797 err = AVERROR(ENOMEM);

798 goto error;

799 }

800 *copy->internal = *src->internal;

801 copy->internal->thread_ctx = p;

802 copy->internal->last_pkt_props = &p->avpkt;

803

804 if (!i) {

805 src = copy;

806

807 if (codec->init)

808 err = codec->init(copy);

809

810 update_context_from_thread(avctx, copy, 1);

811 } else {

812 copy->priv_data = av_malloc(codec->priv_data_size);

813 if (!copy->priv_data) {

814 err = AVERROR(ENOMEM);

815 goto error;

816 }

817 memcpy(copy->priv_data, src->priv_data, codec->priv_data_size);

818 copy->internal->is_copy = 1;

819

820 if (codec->init_thread_copy)

821 err = codec->init_thread_copy(copy);

822 }

823

824 if (err) goto error;

825

826 atomic_init(&p->debug_threads, (copy->debug & FF_DEBUG_THREADS) != 0);

827

828 err = AVERROR(pthread_create(&p->thread, NULL, frame_worker_thread, p));

829 p->thread_init= !err;

830 if(!p->thread_init)

831 goto error;

832 }

833

834 return 0;

835

836 error:

837 ff_frame_thread_free(avctx, i+1);

838

839 return err;

840 }

841

842 void ff_thread_flush(AVCodecContext *avctx)

843 {

844 int i;

845 FrameThreadContext *fctx = avctx->internal->thread_ctx;

846

847 if (!fctx) return;

848

849 park_frame_worker_threads(fctx, avctx->thread_count);

850 if (fctx->prev_thread) {

851 if (fctx->prev_thread != &fctx->threads[0])

852 update_context_from_thread(fctx->threads[0].avctx, fctx->prev_thread->avctx, 0);

853 }

854

855 fctx->next_decoding = fctx->next_finished = 0;

856 fctx->delaying = 1;

857 fctx->prev_thread = NULL;

858 for (i = 0; i < avctx->thread_count; i++) {

859 PerThreadContext *p = &fctx->threads[i];

860 // Make sure decode flush calls with size=0 won't return old frames

861 p->got_frame = 0;

862 av_frame_unref(p->frame);

863 p->result = 0;

864

865 release_delayed_buffers(p);

866

867 if (avctx->codec->flush)

868 avctx->codec->flush(p->avctx);

869 }

870 }

871

872 int ff_thread_can_start_frame(AVCodecContext *avctx)

873 {

874 PerThreadContext *p = avctx->internal->thread_ctx;

875 if ((avctx->active_thread_type&FF_THREAD_FRAME) && atomic_load(&p->state) != STATE_SETTING_UP &&

876 (avctx->codec->update_thread_context || !THREAD_SAFE_CALLBACKS(avctx))) {

877 return 0;

878 }

879 return 1;

880 }

881

882 static int thread_get_buffer_internal(AVCodecContext *avctx, ThreadFrame *f, int flags)

883 {

884 PerThreadContext *p = avctx->internal->thread_ctx;

885 int err;

886

887 f->owner[0] = f->owner[1] = avctx;

888

889 if (!(avctx->active_thread_type & FF_THREAD_FRAME))

890 return ff_get_buffer(avctx, f->f, flags);

891

892 if (atomic_load(&p->state) != STATE_SETTING_UP &&

893 (avctx->codec->update_thread_context || !THREAD_SAFE_CALLBACKS(avctx))) {

894 av_log(avctx, AV_LOG_ERROR, "get_buffer() cannot be called after ff_thread_finish_setup()\n");

895 return -1;

896 }

897

898 if (avctx->internal->allocate_progress) {

899 atomic_int *progress;

900 f->progress = av_buffer_alloc(2 * sizeof(*progress));

901 if (!f->progress) {

902 return AVERROR(ENOMEM);

903 }

904 progress = (atomic_int*)f->progress->data;

905

906 atomic_init(&progress[0], -1);

907 atomic_init(&progress[1], -1);

908 }

909

910 pthread_mutex_lock(&p->parent->buffer_mutex);

911 if (avctx->thread_safe_callbacks ||

912 avctx->get_buffer2 == avcodec_default_get_buffer2) {

913 err = ff_get_buffer(avctx, f->f, flags);

914 } else {

915 pthread_mutex_lock(&p->progress_mutex);

916 p->requested_frame = f->f;

917 p->requested_flags = flags;

918 atomic_store_explicit(&p->state, STATE_GET_BUFFER, memory_order_release);

919 pthread_cond_broadcast(&p->progress_cond);

920

921 while (atomic_load(&p->state) != STATE_SETTING_UP)

922 pthread_cond_wait(&p->progress_cond, &p->progress_mutex);

923

924 err = p->result;

925

926 pthread_mutex_unlock(&p->progress_mutex);

927

928 }

929 if (!THREAD_SAFE_CALLBACKS(avctx) && !avctx->codec->update_thread_context)

930 ff_thread_finish_setup(avctx);

931 if (err)

932 av_buffer_unref(&f->progress);

933

934 pthread_mutex_unlock(&p->parent->buffer_mutex);

935

936 return err;

937 }

938

939 enum AVPixelFormat ff_thread_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)

940 {

941 enum AVPixelFormat res;

942 PerThreadContext *p = avctx->internal->thread_ctx;

943 if (!(avctx->active_thread_type & FF_THREAD_FRAME) || avctx->thread_safe_callbacks ||

944 avctx->get_format == avcodec_default_get_format)

945 return ff_get_format(avctx, fmt);

946 if (atomic_load(&p->state) != STATE_SETTING_UP) {

947 av_log(avctx, AV_LOG_ERROR, "get_format() cannot be called after ff_thread_finish_setup()\n");

948 return -1;

949 }

950 pthread_mutex_lock(&p->progress_mutex);

951 p->available_formats = fmt;

952 atomic_store(&p->state, STATE_GET_FORMAT);

953 pthread_cond_broadcast(&p->progress_cond);

954

955 while (atomic_load(&p->state) != STATE_SETTING_UP)

956 pthread_cond_wait(&p->progress_cond, &p->progress_mutex);

957

958 res = p->result_format;

959

960 pthread_mutex_unlock(&p->progress_mutex);

961

962 return res;

963 }

964

965 int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)

966 {

967 int ret = thread_get_buffer_internal(avctx, f, flags);

968 if (ret < 0)

969 av_log(avctx, AV_LOG_ERROR, "thread_get_buffer() failed\n");

970 return ret;

971 }

972

973 void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)

974 {

975 PerThreadContext *p = avctx->internal->thread_ctx;

976 FrameThreadContext *fctx;

977 AVFrame *dst, *tmp;

978 int can_direct_free = !(avctx->active_thread_type & FF_THREAD_FRAME) ||

979 avctx->thread_safe_callbacks ||

980 avctx->get_buffer2 == avcodec_default_get_buffer2;

981

982 if (!f->f || !f->f->buf[0])

983 return;

984

985 if (avctx->debug & FF_DEBUG_BUFFERS)

986 av_log(avctx, AV_LOG_DEBUG, "thread_release_buffer called on pic %p\n", f);

987

988 av_buffer_unref(&f->progress);

989 f->owner[0] = f->owner[1] = NULL;

990

991 if (can_direct_free) {

992 av_frame_unref(f->f);

993 return;

994 }

995

996 fctx = p->parent;

997 pthread_mutex_lock(&fctx->buffer_mutex);

998

999 if (p->num_released_buffers + 1 >= INT_MAX / sizeof(*p->released_buffers))

1000 goto fail;

1001 tmp = av_fast_realloc(p->released_buffers, &p->released_buffers_allocated,

1002 (p->num_released_buffers + 1) *

1003 sizeof(*p->released_buffers));

1004 if (!tmp)

1005 goto fail;

1006 p->released_buffers = tmp;

1007

1008 dst = &p->released_buffers[p->num_released_buffers];

1009 av_frame_move_ref(dst, f->f);

1010

1011 p->num_released_buffers++;

1012

1013 fail:

1014 pthread_mutex_unlock(&fctx->buffer_mutex);

1015 }

thread_get_buffer_internal

static int thread_get_buffer_internal(AVCodecContext *avctx, ThreadFrame *f, int flags)

Definition: pthread_frame.c:882

AVHWAccel::caps_internal

int caps_internal

Internal hwaccel capabilities.

Definition: avcodec.h:3725

PerThreadContext::progress_cond

pthread_cond_t progress_cond

Used by child threads to wait for progress to change.

Definition: pthread_frame.c:76

NULL

#define NULL

Definition: coverity.c:32

ff_get_format

int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)

Select the (possibly hardware accelerated) pixel format.

Definition: decode.c:1299

AVCodecContext::codec

const struct AVCodec * codec

Definition: avcodec.h:1527

AVCodecContext::framerate

AVRational framerate

Definition: avcodec.h:3040

AV_CODEC_PROP_INTRA_ONLY

#define AV_CODEC_PROP_INTRA_ONLY

Codec uses only intra compression.

Definition: avcodec.h:733

AVCodecContext::codec_descriptor

const AVCodecDescriptor * codec_descriptor

AVCodecDescriptor.

Definition: avcodec.h:3061

hwaccel.h

pthread_mutex_destroy

static av_always_inline int pthread_mutex_destroy(pthread_mutex_t *mutex)

Definition: os2threads.h:108

copy

static void copy(const float *p1, float *p2, const int length)

Definition: vf_vaguedenoiser.c:185

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

copy_fields

#define copy_fields(s, e)

AVFrame

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

Definition: frame.h:218

pthread_mutex_lock

#define pthread_mutex_lock(a)

Definition: ffprobe.c:61

pthread_cond_wait

static av_always_inline int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)

Definition: os2threads.h:166

atomic_store

#define atomic_store(object, desired)

Definition: stdatomic.h:85

PerThreadContext

Context used by codec threads and stored in their AVCodecInternal thread_ctx.

Definition: pthread_frame.c:70

av_cpu_count

int av_cpu_count(void)

Definition: cpu.c:267

PerThreadContext::requested_frame

AVFrame * requested_frame

AVFrame the codec passed to get_buffer()

Definition: pthread_frame.c:100

AVCodecContext::coded_width

int coded_width

Bitstream width / height, may be different from width/height e.g.

Definition: avcodec.h:1705

fmt

const char * fmt

Definition: avisynth_c.h:769

AVCodec::flush

void(* flush)(AVCodecContext *)

Flush buffers.

Definition: avcodec.h:3529

PerThreadContext::state

atomic_int state

Definition: pthread_frame.c:90

AVCodecInternal::last_pkt_props

AVPacket * last_pkt_props

Properties (timestamps+side data) extracted from the last packet passed for decoding.

Definition: internal.h:172

submit_packet

static int submit_packet(PerThreadContext *p, AVCodecContext *user_avctx, AVPacket *avpkt)

Definition: pthread_frame.c:380

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:182

ThreadFrame::f

AVFrame * f

Definition: thread.h:35

mem.h

Memory handling functions.

AVFrame::buf

AVBufferRef * buf[AV_NUM_DATA_POINTERS]

AVBuffer references backing the data for this frame.

Definition: frame.h:410

AVCodecContext::color_range

enum AVColorRange color_range

MPEG vs JPEG YUV range.

Definition: avcodec.h:2148

AVPacket::size

int size

Definition: avcodec.h:1431

AVCodecContext::sample_aspect_ratio

AVRational sample_aspect_ratio

sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...

Definition: avcodec.h:1896

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:1727

av_frame_move_ref

void av_frame_move_ref(AVFrame *dst, AVFrame *src)

Move everything contained in src to dst and reset src.

Definition: frame.c:580

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

AVCodec::decode

int(* decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt)

Definition: avcodec.h:3506

AVCodecContext::bits_per_raw_sample

int bits_per_raw_sample

Bits per sample/pixel of internal libavcodec pixel/sample format.

Definition: avcodec.h:2741

PerThreadContext::input_cond

pthread_cond_t input_cond

Used to wait for a new packet from the main thread.

Definition: pthread_frame.c:75

atomic_int

intptr_t atomic_int

Definition: stdatomic.h:55

ff_thread_await_progress

void ff_thread_await_progress(ThreadFrame *f, int n, int field)

Wait for earlier decoding threads to finish reference pictures.

Definition: pthread_frame.c:580

AVCodecContext::hwaccel

const struct AVHWAccel * hwaccel

Hardware accelerator in use.

Definition: avcodec.h:2674

src

#define src

Definition: vp8dsp.c:254

AVCodecContext::profile

int profile

profile

Definition: avcodec.h:2843

PerThreadContext::available_formats

enum AVPixelFormat * available_formats

Format array for get_format()

Definition: pthread_frame.c:103

AVCodec

AVCodec.

Definition: avcodec.h:3408

pthread_cond_destroy

static av_always_inline int pthread_cond_destroy(pthread_cond_t *cond)

Definition: os2threads.h:140

PerThreadContext::avpkt

AVPacket avpkt

Input packet (for decoding) or output (for encoding).

Definition: pthread_frame.c:84

AVCodecContext::time_base

AVRational time_base

This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...

Definition: avcodec.h:1640

AV_CODEC_CAP_DELAY

#define AV_CODEC_CAP_DELAY

Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...

Definition: avcodec.h:984

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:37

AVCodec::init_thread_copy

int(* init_thread_copy)(AVCodecContext *)

If defined, called on thread contexts when they are created.

Definition: avcodec.h:3467

avcodec_default_get_format

enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum AVPixelFormat *fmt)

Definition: decode.c:1087

AVCodecContext::sample_fmt

enum AVSampleFormat sample_fmt

audio sample format

Definition: avcodec.h:2181

config.h

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:31

av_frame_alloc

AVFrame * av_frame_alloc(void)

Allocate an AVFrame and set its fields to default values.

Definition: frame.c:189

AVCodecContext::hwaccel_context

void * hwaccel_context

Hardware accelerator context.

Definition: avcodec.h:2686

opt.h

AVOptions.

frame_worker_thread

static attribute_align_arg void * frame_worker_thread(void *arg)

Codec worker thread.

Definition: pthread_frame.c:168

AVCodecInternal::thread_ctx

void * thread_ctx

Definition: internal.h:163

thread.h

Multithreading support functions.

THREAD_SAFE_CALLBACKS

#define THREAD_SAFE_CALLBACKS(avctx)

Definition: pthread_frame.c:140

FrameThreadContext::hwaccel_mutex

pthread_mutex_t hwaccel_mutex

This lock is used for ensuring threads run in serial when hwaccel is used.

Definition: pthread_frame.c:126

STATE_GET_BUFFER

Set when the codec calls get_buffer().

Definition: pthread_frame.c:57

finish

static void finish(void)

Definition: movenc.c:345

pthread_cond_t

Definition: os2threads.h:54

PerThreadContext::requested_flags

int requested_flags

flags passed to get_buffer() for requested_frame

Definition: pthread_frame.c:101

FrameThreadContext::next_decoding

int next_decoding

The next context to submit a packet to.

Definition: pthread_frame.c:131

flags

static int flags

Definition: log.c:55

pthread_cond_signal

static av_always_inline int pthread_cond_signal(pthread_cond_t *cond)

Definition: os2threads.h:148

AVCodecContext::bits_per_coded_sample

int bits_per_coded_sample

bits per sample/pixel from the demuxer (needed for huffyuv).

Definition: avcodec.h:2734

ff_thread_finish_setup

void ff_thread_finish_setup(AVCodecContext *avctx)

If the codec defines update_thread_context(), call this when they are ready for the next thread to st...

Definition: pthread_frame.c:601

AVCodecContext::chroma_sample_location

enum AVChromaLocation chroma_sample_location

This defines the location of chroma samples.

Definition: avcodec.h:2155

FrameThreadContext

Context stored in the client AVCodecInternal thread_ctx.

Definition: pthread_frame.c:117

PerThreadContext::avctx

AVCodecContext * avctx

Context used to decode packets passed to this thread.

Definition: pthread_frame.c:82

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:28

av_packet_ref

int av_packet_ref(AVPacket *dst, const AVPacket *src)

Setup a new reference to the data described by a given packet.

Definition: avpacket.c:601

pthread_internal.h

PerThreadContext::die

int die

Set when the thread should exit.

Definition: pthread_frame.c:106

ff_thread_decode_frame

int ff_thread_decode_frame(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, AVPacket *avpkt)

Submit a new frame to a decoding thread.

Definition: pthread_frame.c:472

AVCodecContext::slice_count

int slice_count

slice count

Definition: avcodec.h:1871

version.h

Libavcodec version macros.

AVCodec::close

int(* close)(AVCodecContext *)

Definition: avcodec.h:3507

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:176

AVCodecContext::has_b_frames

int has_b_frames

Size of the frame reordering buffer in the decoder.

Definition: avcodec.h:1807

FrameThreadContext::prev_thread

PerThreadContext * prev_thread

The last thread submit_packet() was called on.

Definition: pthread_frame.c:119

ff_frame_thread_free

void ff_frame_thread_free(AVCodecContext *avctx, int thread_count)

Definition: pthread_frame.c:652

ff_thread_release_buffer

void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)

Wrapper around release_buffer() frame-for multithreaded codecs.

Definition: pthread_frame.c:973

atomic_load

#define atomic_load(object)

Definition: stdatomic.h:93

AVCodecInternal::is_copy

int is_copy

Whether the parent AVCodecContext is a copy of the context which had init() called on it...

Definition: internal.h:136

AVERROR

#define AVERROR(e)

Definition: error.h:43

av_frame_free

void av_frame_free(AVFrame **frame)

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

Definition: frame.c:202

AVCodecContext::active_thread_type

int active_thread_type

Which multithreading methods are in use by the codec.

Definition: avcodec.h:2788

AVCodec::capabilities

int capabilities

Codec capabilities.

Definition: avcodec.h:3427

PerThreadContext::result

int result

The result of the last codec decode/encode() call.

Definition: pthread_frame.c:88

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:197

arg

const char * arg

Definition: jacosubdec.c:66

AVCodecContext::flags

int flags

AV_CODEC_FLAG_*.

Definition: avcodec.h:1598

AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

avassert.h

simple assert() macros that are a bit more flexible than ISO C assert().

fail

#define fail()

Definition: checkasm.h:116

frame.h

reference-counted frame API

AVCodecContext::channel_layout

uint64_t channel_layout

Audio channel layout.

Definition: avcodec.h:2224

av_reallocp_array

int av_reallocp_array(void *ptr, size_t nmemb, size_t size)

Definition: mem.c:205

AVCodecDescriptor::props

int props

Codec properties, a combination of AV_CODEC_PROP_* flags.

Definition: avcodec.h:715

internal.h

common internal API header

PerThreadContext::output_cond

pthread_cond_t output_cond

Used by the main thread to wait for frames to finish.

Definition: pthread_frame.c:77

AVCodecContext::draw_horiz_band

void(* draw_horiz_band)(struct AVCodecContext *s, const AVFrame *src, int offset[AV_NUM_DATA_POINTERS], int y, int type, int height)

If non NULL, 'draw_horiz_band' is called by the libavcodec decoder to draw a horizontal band...

Definition: avcodec.h:1752

FF_THREAD_FRAME

#define FF_THREAD_FRAME

Decode more than one frame at once.

Definition: avcodec.h:2780

FFMIN

#define FFMIN(a, b)

Definition: common.h:96

AVCodecContext::width

int width

picture width / height.

Definition: avcodec.h:1690

AVCodecContext::idct_algo

int idct_algo

IDCT algorithm, see FF_IDCT_* below.

Definition: avcodec.h:2713

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

AVCodec::priv_data_size

int priv_data_size

Definition: avcodec.h:3456

ff_thread_report_progress

void ff_thread_report_progress(ThreadFrame *f, int n, int field)

Notify later decoding threads when part of their reference picture is ready.

Definition: pthread_frame.c:557

atomic_load_explicit

#define atomic_load_explicit(object, order)

Definition: stdatomic.h:96

AVCodecContext::color_primaries

enum AVColorPrimaries color_primaries

Chromaticity coordinates of the source primaries.

Definition: avcodec.h:2127

pthread_join

static av_always_inline int pthread_join(pthread_t thread, void **value_ptr)

Definition: os2threads.h:90

pthread_mutex_init

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

Definition: os2threads.h:100

AVCodecContext::level

int level

level

Definition: avcodec.h:2953

FrameThreadContext::async_lock

int async_lock

Definition: pthread_frame.c:129

FF_DEBUG_BUFFERS

#define FF_DEBUG_BUFFERS

Definition: avcodec.h:2620

PerThreadContext::num_released_buffers

int num_released_buffers

Definition: pthread_frame.c:97

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

AVCodecContext::reordered_opaque

int64_t reordered_opaque

opaque 64-bit number (generally a PTS) that will be reordered and output in AVFrame.reordered_opaque

Definition: avcodec.h:2667

int n

Definition: avisynth_c.h:684

AVCodecContext::ticks_per_frame

int ticks_per_frame

For some codecs, the time base is closer to the field rate than the frame rate.

Definition: avcodec.h:1649

PerThreadContext::thread

pthread_t thread

Definition: pthread_frame.c:73

ThreadFrame

Definition: thread.h:34

pthread_mutex_unlock

#define pthread_mutex_unlock(a)

Definition: ffprobe.c:65

FF_DEBUG_THREADS

#define FF_DEBUG_THREADS

Definition: avcodec.h:2621

AVCodecContext::height

int height

Definition: avcodec.h:1690

error

static void error(const char *err)

Definition: target_dec_fuzzer.c:59

AVCodecContext::thread_count

int thread_count

thread count is used to decide how many independent tasks should be passed to execute() ...

Definition: avcodec.h:2769

PerThreadContext::got_frame

int got_frame

The output of got_picture_ptr from the last avcodec_decode_video() call.

Definition: pthread_frame.c:87

update_context_from_user

static int update_context_from_user(AVCodecContext *dst, AVCodecContext *src)

Update the next thread's AVCodecContext with values set by the user.

Definition: pthread_frame.c:323

FrameThreadContext::buffer_mutex

pthread_mutex_t buffer_mutex

Mutex used to protect get/release_buffer().

Definition: pthread_frame.c:121

ThreadFrame::progress

AVBufferRef * progress

Definition: thread.h:39

PerThreadContext::progress_mutex

pthread_mutex_t progress_mutex

Mutex used to protect frame progress values and progress_cond.

Definition: pthread_frame.c:80

pthread_create

static av_always_inline int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg)

Definition: os2threads.h:76

FrameThreadContext::async_cond

pthread_cond_t async_cond

Definition: pthread_frame.c:128

PerThreadContext::async_serializing

int async_serializing

Definition: pthread_frame.c:109

avcodec_default_get_buffer2

int avcodec_default_get_buffer2(AVCodecContext *s, AVFrame *frame, int flags)

The default callback for AVCodecContext.get_buffer2().

Definition: decode.c:1629

avcodec.h

Libavcodec external API header.

AVCodecContext::codec_type

enum AVMediaType codec_type

Definition: avcodec.h:1526

AVCodecInternal

Definition: internal.h:129

AVCodecContext::codec_id

enum AVCodecID codec_id

Definition: avcodec.h:1528

av_buffer_alloc

AVBufferRef * av_buffer_alloc(int size)

Allocate an AVBuffer of the given size using av_malloc().

Definition: buffer.c:67

AVCodecContext::sample_rate

int sample_rate

samples per second

Definition: avcodec.h:2173

cpu.h

AVCodecContext::debug

int debug

debug

Definition: avcodec.h:2598

ff_thread_get_buffer

int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)

Wrapper around get_buffer() for frame-multithreaded codecs.

Definition: pthread_frame.c:965

AVCodecContext

main external API structure.

Definition: avcodec.h:1518

av_packet_unref

void av_packet_unref(AVPacket *pkt)

Wipe the packet.

Definition: avpacket.c:592

AVBufferRef::data

uint8_t * data

The data buffer.

Definition: buffer.h:89

ff_get_buffer

int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)

Get a buffer for a frame.

Definition: decode.c:1891

AVCodecContext::slice_flags

int slice_flags

slice flags

Definition: avcodec.h:1995

ThreadFrame::owner

AVCodecContext * owner[2]

Definition: thread.h:36

AVCodecContext::coded_height

int coded_height

Definition: avcodec.h:1705

AVCodecContext::get_format

enum AVPixelFormat(* get_format)(struct AVCodecContext *s, const enum AVPixelFormat *fmt)

callback to negotiate the pixelFormat

Definition: avcodec.h:1769

AVCodecContext::colorspace

enum AVColorSpace colorspace

YUV colorspace type.

Definition: avcodec.h:2141

AVCodecContext::color_trc

enum AVColorTransferCharacteristic color_trc

Color Transfer Characteristic.

Definition: avcodec.h:2134

PerThreadContext::result_format

enum AVPixelFormat result_format

get_format() result

Definition: pthread_frame.c:104

FrameThreadContext::delaying

int delaying

Set for the first N packets, where N is the number of threads.

Definition: pthread_frame.c:134

STATE_SETUP_FINISHED

Definition: pthread_frame.c:64

buffer.h

refcounted data buffer API

ff_thread_get_format

enum AVPixelFormat ff_thread_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)

Wrapper around get_format() for frame-multithreaded codecs.

Definition: pthread_frame.c:939

AVCodecContext::get_buffer2

int(* get_buffer2)(struct AVCodecContext *s, AVFrame *frame, int flags)

This callback is called at the beginning of each frame to get data buffer(s) for it.

Definition: avcodec.h:2328

PerThreadContext::thread_init

int thread_init

Definition: pthread_frame.c:74

atomic_store_explicit

#define atomic_store_explicit(object, desired, order)

Definition: stdatomic.h:90

async_unlock

static void async_unlock(FrameThreadContext *fctx)

Definition: pthread_frame.c:152

FrameThreadContext::threads

PerThreadContext * threads

The contexts for each thread.

Definition: pthread_frame.c:118

AVCodecInternal::allocate_progress

int allocate_progress

Whether to allocate progress for frame threading.

Definition: internal.h:151

async_lock

static void async_lock(FrameThreadContext *fctx)

Definition: pthread_frame.c:143

MAX_AUTO_THREADS

#define MAX_AUTO_THREADS

Definition: pthread_internal.h:26

PerThreadContext::released_buffers

AVFrame * released_buffers

Array of frames passed to ff_thread_release_buffer().

Definition: pthread_frame.c:96

PerThreadContext::parent

struct FrameThreadContext * parent

Definition: pthread_frame.c:71

av_frame_unref

void av_frame_unref(AVFrame *frame)

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

Definition: frame.c:551

STATE_INPUT_READY

Set when the thread is awaiting a packet.

Definition: pthread_frame.c:50

AVCodec::priv_class

const AVClass * priv_class

AVClass for the private context.

Definition: avcodec.h:3434

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:232

AVFrame::pkt_dts

int64_t pkt_dts

DTS copied from the AVPacket that triggered returning this frame.

Definition: frame.h:327

AV_CODEC_ID_FFV1

Definition: avcodec.h:251

av_opt_free

void av_opt_free(void *obj)

Free all allocated objects in obj.

Definition: opt.c:1545

FF_DISABLE_DEPRECATION_WARNINGS

#define FF_DISABLE_DEPRECATION_WARNINGS

Definition: internal.h:84

internal.h

common internal api header.

pthread_mutex_t

_fmutex pthread_mutex_t

Definition: os2threads.h:49

common.h

common internal and external API header

if(ret< 0)

Definition: vf_mcdeint.c:279

STATE_SETTING_UP

Definition: pthread_frame.c:52

PerThreadContext::released_buffers_allocated

int released_buffers_allocated

Definition: pthread_frame.c:98

AVCodecInternal::hwaccel_priv_data

void * hwaccel_priv_data

hwaccel-specific private data

Definition: internal.h:190

av_buffer_ref

AVBufferRef * av_buffer_ref(AVBufferRef *buf)

Create a new reference to an AVBuffer.

Definition: buffer.c:93

update_context_from_thread

static int update_context_from_thread(AVCodecContext *dst, AVCodecContext *src, int for_user)

Update the next thread's AVCodecContext with values from the reference thread's context.

Definition: pthread_frame.c:245

PerThreadContext::hwaccel_serializing

int hwaccel_serializing

Definition: pthread_frame.c:108

pthread_cond_init

static av_always_inline int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr)

Definition: os2threads.h:129

AVCodecContext::coded_frame

attribute_deprecated AVFrame * coded_frame

the picture in the bitstream

Definition: avcodec.h:2760

AVCodecContext::thread_safe_callbacks

int thread_safe_callbacks

Set by the client if its custom get_buffer() callback can be called synchronously from another thread...

Definition: avcodec.h:2798

HWACCEL_CAP_ASYNC_SAFE

#define HWACCEL_CAP_ASYNC_SAFE

Definition: hwaccel.h:26

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:1545

AVCodec::update_thread_context

int(* update_thread_context)(AVCodecContext *dst, const AVCodecContext *src)

Copy necessary context variables from a previous thread context to the current one.

Definition: avcodec.h:3475

ff_thread_flush

void ff_thread_flush(AVCodecContext *avctx)

Wait for decoding threads to finish and reset internal state.

Definition: pthread_frame.c:842

STATE_GET_FORMAT

Set when the codec calls get_format().

Definition: pthread_frame.c:62

PerThreadContext::frame

AVFrame * frame

Output frame (for decoding) or input (for encoding).

Definition: pthread_frame.c:86

ff_thread_can_start_frame

int ff_thread_can_start_frame(AVCodecContext *avctx)

Definition: pthread_frame.c:872

FF_ENABLE_DEPRECATION_WARNINGS

#define FF_ENABLE_DEPRECATION_WARNINGS

Definition: internal.h:85

pthread_t

Definition: os2threads.h:40

pthread_cond_broadcast

static av_always_inline int pthread_cond_broadcast(pthread_cond_t *cond)

Definition: os2threads.h:158

AVCodecContext::channels

int channels

number of audio channels

Definition: avcodec.h:2174

AVCodecContext::internal

struct AVCodecInternal * internal

Private context used for internal data.

Definition: avcodec.h:1553

PerThreadContext::mutex

pthread_mutex_t mutex

Mutex used to protect the contents of the PerThreadContext.

Definition: pthread_frame.c:79

log.h

AVCodecContext::flags2

int flags2

AV_CODEC_FLAG2_*.

Definition: avcodec.h:1605

park_frame_worker_threads

static void park_frame_worker_threads(FrameThreadContext *fctx, int thread_count)

Waits for all threads to finish.

Definition: pthread_frame.c:631

FrameThreadContext::async_mutex

pthread_mutex_t async_mutex

Definition: pthread_frame.c:127

AVPacket::dts

int64_t dts

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

Definition: avcodec.h:1429

AVCodecContext::slice_offset

int * slice_offset

slice offsets in the frame in bytes

Definition: avcodec.h:1887

AVCodecContext::frame_number

int frame_number

Frame counter, set by libavcodec.

Definition: avcodec.h:2204

PerThreadContext::debug_threads

atomic_int debug_threads

Set if the FF_DEBUG_THREADS option is set.

Definition: pthread_frame.c:111

release_delayed_buffers

static void release_delayed_buffers(PerThreadContext *p)

Releases the buffers that this decoding thread was the last user of.

Definition: pthread_frame.c:360

atomic_init

#define atomic_init(obj, value)

Definition: stdatomic.h:33

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:35

AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

AVCodecContext::hwaccel_flags

int hwaccel_flags

Bit set of AV_HWACCEL_FLAG_* flags, which affect hardware accelerated decoding (if active)...

Definition: avcodec.h:3258

AVCodecContext::debug_mv

int debug_mv

debug motion vectors

Definition: avcodec.h:3128

FrameThreadContext::next_finished

int next_finished

The next context to return output from.

Definition: pthread_frame.c:132

AVCodec::init

int(* init)(AVCodecContext *)

Definition: avcodec.h:3491

AVFrame::extended_data

uint8_t ** extended_data

pointers to the data planes/channels.

Definition: frame.h:265

AVPixelFormat

Pixel format.

Definition: pixfmt.h:60

AVPacket

This structure stores compressed data.

Definition: avcodec.h:1407

AVCodecContext::delay

int delay

Codec delay.

Definition: avcodec.h:1673

ff_frame_thread_init

int ff_frame_thread_init(AVCodecContext *avctx)

Definition: pthread_frame.c:723

AVCodecContext::sw_pix_fmt

enum AVPixelFormat sw_pix_fmt

Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:3047

AVCodecContext::opaque

void * opaque

Private data of the user, can be used to carry app specific stuff.

Definition: avcodec.h:1560

av_mallocz_array

void * av_mallocz_array(size_t nmemb, size_t size)

Definition: mem.c:191

thread.h

tmp

static uint8_t tmp[11]

Definition: aes_ctr.c:26

Generated on Sun May 13 2018 02:03:54 for FFmpeg by doxygen 1.8.6