Go to the documentation of this file.
29 #include "config_components.h"
47 #define ALPHA_SHIFT_16_TO_10(alpha_val) (alpha_val >> 6)
48 #define ALPHA_SHIFT_8_TO_10(alpha_val) ((alpha_val << 2) | (alpha_val >> 6))
49 #define ALPHA_SHIFT_16_TO_12(alpha_val) (alpha_val >> 4)
50 #define ALPHA_SHIFT_8_TO_12(alpha_val) ((alpha_val << 4) | (alpha_val >> 4))
53 const int num_bits,
const int decode_precision) {
54 const int mask = (1 << num_bits) - 1;
55 int i, idx,
val, alpha_val;
71 alpha_val = (alpha_val +
val) &
mask;
73 if (decode_precision == 10) {
79 if (decode_precision == 10) {
85 if (idx >= num_coeffs)
91 if (idx +
val > num_coeffs)
92 val = num_coeffs - idx;
94 for (
i = 0;
i <
val;
i++) {
95 if (decode_precision == 10) {
102 for (
i = 0;
i <
val;
i++) {
103 if (decode_precision == 10) {
110 }
while (idx < num_coeffs);
116 if (num_bits == 16) {
126 if (num_bits == 16) {
140 case MKTAG(
'a',
'p',
'c',
'o'):
143 case MKTAG(
'a',
'p',
'c',
's'):
146 case MKTAG(
'a',
'p',
'c',
'n'):
149 case MKTAG(
'a',
'p',
'c',
'h'):
152 case MKTAG(
'a',
'p',
'4',
'h'):
156 case MKTAG(
'a',
'p',
'4',
'x'):
169 "Auto bitdepth precision. Use %db decoding based on codec tag.\n",
176 ctx->prodsp.idct_permutation);
178 ctx->prodsp.idct_permutation);
194 ff_dlog(avctx,
"header size %d\n", hdr_size);
195 if (hdr_size > data_size) {
219 ctx->frame_type = (buf[12] >> 2) & 3;
220 ctx->alpha_info = buf[17] & 0xf;
222 if (
ctx->alpha_info > 2) {
228 ff_dlog(avctx,
"frame type %d\n",
ctx->frame_type);
230 if (
ctx->frame_type == 0) {
231 ctx->scan =
ctx->progressive_scan;
233 ctx->scan =
ctx->interlaced_scan;
235 if (
ctx->frame_type == 1)
239 if (
ctx->alpha_info) {
254 #define HWACCEL_MAX (CONFIG_PRORES_VIDEOTOOLBOX_HWACCEL)
261 #if CONFIG_PRORES_VIDEOTOOLBOX_HWACCEL
264 *fmtp++ =
ctx->pix_fmt;
276 ctx->frame->color_primaries = buf[14];
277 ctx->frame->color_trc = buf[15];
278 ctx->frame->colorspace = buf[16];
286 if(buf + data_size - ptr < 64) {
293 memset(
ctx->qmat_luma, 4, 64);
297 if(buf + data_size - ptr < 64) {
303 memcpy(
ctx->qmat_chroma,
ctx->qmat_luma, 64);
312 int i, hdr_size, slice_count;
313 unsigned pic_data_size;
314 int log2_slice_mb_width, log2_slice_mb_height;
315 int slice_mb_count, mb_x, mb_y;
316 const uint8_t *data_ptr, *index_ptr;
318 hdr_size = buf[0] >> 3;
319 if (hdr_size < 8 || hdr_size > buf_size) {
324 pic_data_size =
AV_RB32(buf + 1);
325 if (pic_data_size > buf_size) {
330 log2_slice_mb_width = buf[7] >> 4;
331 log2_slice_mb_height = buf[7] & 0xF;
332 if (log2_slice_mb_width > 3 || log2_slice_mb_height) {
334 1 << log2_slice_mb_width, 1 << log2_slice_mb_height);
338 ctx->mb_width = (avctx->
width + 15) >> 4;
340 ctx->mb_height = (avctx->
height + 31) >> 5;
342 ctx->mb_height = (avctx->
height + 15) >> 4;
346 slice_count =
ctx->mb_height * ((
ctx->mb_width >> log2_slice_mb_width) +
349 if (
ctx->slice_count != slice_count || !
ctx->slices) {
351 ctx->slice_count = 0;
355 ctx->slice_count = slice_count;
361 if (hdr_size + slice_count*2 > buf_size) {
367 index_ptr = buf + hdr_size;
368 data_ptr = index_ptr + slice_count*2;
370 slice_mb_count = 1 << log2_slice_mb_width;
374 for (
i = 0;
i < slice_count;
i++) {
377 slice->
data = data_ptr;
378 data_ptr +=
AV_RB16(index_ptr +
i*2);
380 while (
ctx->mb_width - mb_x < slice_mb_count)
381 slice_mb_count >>= 1;
393 mb_x += slice_mb_count;
394 if (mb_x ==
ctx->mb_width) {
395 slice_mb_count = 1 << log2_slice_mb_width;
399 if (data_ptr > buf + buf_size) {
405 if (mb_x || mb_y !=
ctx->mb_height) {
407 mb_y,
ctx->mb_height);
411 return pic_data_size;
414 #define DECODE_CODEWORD(val, codebook, SKIP) \
416 unsigned int rice_order, exp_order, switch_bits; \
417 unsigned int q, buf, bits; \
419 UPDATE_CACHE_32(re, gb); \
420 buf = GET_CACHE(re, gb); \
423 switch_bits = codebook & 3; \
424 rice_order = codebook >> 5; \
425 exp_order = (codebook >> 2) & 7; \
427 q = 31 - av_log2(buf); \
429 if (q > switch_bits) { \
430 bits = exp_order - switch_bits + (q<<1); \
432 return AVERROR_INVALIDDATA; \
433 val = SHOW_UBITS(re, gb, bits) - (1 << exp_order) + \
434 ((switch_bits + 1) << rice_order); \
435 SKIP(re, gb, bits); \
436 } else if (rice_order) { \
437 SKIP_BITS(re, gb, q+1); \
438 val = (q << rice_order) + SHOW_UBITS(re, gb, rice_order); \
439 SKIP(re, gb, rice_order); \
446 #define TOSIGNED(x) (((x) >> 1) ^ (-((x) & 1)))
448 #define FIRST_DC_CB 0xB8
450 static const uint8_t
dc_codebook[7] = { 0x04, 0x28, 0x28, 0x4D, 0x4D, 0x70, 0x70};
453 int blocks_per_slice)
468 for (
i = 1;
i < blocks_per_slice;
i++,
out += 64) {
472 prev_dc += (((
code + 1) >> 1) ^ sign) - sign;
480 static const uint8_t
run_to_cb[16] = { 0x06, 0x06, 0x05, 0x05, 0x04, 0x29, 0x29, 0x29, 0x29, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x4C };
481 static const uint8_t
lev_to_cb[10] = { 0x04, 0x0A, 0x05, 0x06, 0x04, 0x28, 0x28, 0x28, 0x28, 0x4C };
484 int16_t *
out,
int blocks_per_slice)
487 int block_mask, sign;
490 int log2_block_count =
av_log2(blocks_per_slice);
497 max_coeffs = 64 << log2_block_count;
498 block_mask = blocks_per_slice - 1;
500 for (
pos = block_mask;;) {
507 if (
pos >= max_coeffs) {
515 i =
pos >> log2_block_count;
519 out[((
pos & block_mask) << 6) +
ctx->scan[
i]] = ((
level ^ sign) - sign);
527 uint16_t *
dst,
int dst_stride,
528 const uint8_t *buf,
unsigned buf_size,
535 int i, blocks_per_slice = slice->
mb_count<<2;
538 for (
i = 0;
i < blocks_per_slice;
i++)
539 ctx->bdsp.clear_block(blocks+(
i<<6));
550 ctx->prodsp.idct_put(
dst, dst_stride,
block+(0<<6), qmat);
551 ctx->prodsp.idct_put(
dst +8, dst_stride,
block+(1<<6), qmat);
552 ctx->prodsp.idct_put(
dst+4*dst_stride , dst_stride,
block+(2<<6), qmat);
553 ctx->prodsp.idct_put(
dst+4*dst_stride+8, dst_stride,
block+(3<<6), qmat);
561 uint16_t *
dst,
int dst_stride,
562 const uint8_t *buf,
unsigned buf_size,
563 const int16_t *qmat,
int log2_blocks_per_mb)
569 int i, j, blocks_per_slice = slice->
mb_count << log2_blocks_per_mb;
572 for (
i = 0;
i < blocks_per_slice;
i++)
573 ctx->bdsp.clear_block(blocks+(
i<<6));
584 for (j = 0; j < log2_blocks_per_mb; j++) {
585 ctx->prodsp.idct_put(
dst, dst_stride,
block+(0<<6), qmat);
586 ctx->prodsp.idct_put(
dst+4*dst_stride, dst_stride,
block+(1<<6), qmat);
598 uint16_t *
dst,
int dst_stride,
599 const uint8_t *buf,
int buf_size,
600 int blocks_per_slice)
607 for (
i = 0;
i < blocks_per_slice<<2;
i++)
608 ctx->bdsp.clear_block(blocks+(
i<<6));
612 if (
ctx->alpha_info == 2) {
613 ctx->unpack_alpha(&gb, blocks, blocks_per_slice * 4 * 64, 16);
615 ctx->unpack_alpha(&gb, blocks, blocks_per_slice * 4 * 64, 8);
620 for (
i = 0;
i < 16;
i++) {
621 memcpy(
dst,
block, 16 * blocks_per_slice *
sizeof(*
dst));
622 dst += dst_stride >> 1;
623 block += 16 * blocks_per_slice;
631 const uint8_t *buf = slice->
data;
633 int i, hdr_size, qscale, log2_chroma_blocks_per_mb;
634 int luma_stride, chroma_stride;
635 int y_data_size, u_data_size, v_data_size, a_data_size,
offset;
636 uint8_t *dest_y, *dest_u, *dest_v;
641 uint16_t val_no_chroma;
648 hdr_size = buf[0] >> 3;
649 qscale =
av_clip(buf[1], 1, 224);
650 qscale = qscale > 128 ? qscale - 96 << 2: qscale;
651 y_data_size =
AV_RB16(buf + 2);
652 u_data_size =
AV_RB16(buf + 4);
653 v_data_size = slice->
data_size - y_data_size - u_data_size - hdr_size;
654 if (hdr_size > 7) v_data_size =
AV_RB16(buf + 6);
655 a_data_size = slice->
data_size - y_data_size - u_data_size -
656 v_data_size - hdr_size;
658 if (y_data_size < 0 || u_data_size < 0 || v_data_size < 0
659 || hdr_size+y_data_size+u_data_size+v_data_size > slice->
data_size){
666 for (
i = 0;
i < 64;
i++) {
667 qmat_luma_scaled [
i] =
ctx->qmat_luma [
i] * qscale;
668 qmat_chroma_scaled[
i] =
ctx->qmat_chroma[
i] * qscale;
671 if (
ctx->frame_type == 0) {
675 luma_stride = pic->
linesize[0] << 1;
676 chroma_stride = pic->
linesize[1] << 1;
682 log2_chroma_blocks_per_mb = 2;
685 log2_chroma_blocks_per_mb = 1;
690 dest_u = pic->
data[1] + (slice->
mb_y << 4) * chroma_stride + (slice->
mb_x << mb_x_shift);
691 dest_v = pic->
data[2] + (slice->
mb_y << 4) * chroma_stride + (slice->
mb_x << mb_x_shift);
701 buf, y_data_size, qmat_luma_scaled);
707 buf + y_data_size, u_data_size,
708 qmat_chroma_scaled, log2_chroma_blocks_per_mb);
713 buf + y_data_size + u_data_size, v_data_size,
714 qmat_chroma_scaled, log2_chroma_blocks_per_mb);
719 size_t mb_max_x = slice->
mb_count << (mb_x_shift - 1);
724 val_no_chroma = 511 * 4;
726 for (
i = 0;
i < 16; ++
i)
727 for (j = 0; j < mb_max_x; ++j) {
728 *(uint16_t*)(dest_u + (
i * chroma_stride) + (j << 1)) = val_no_chroma;
729 *(uint16_t*)(dest_v + (
i * chroma_stride) + (j << 1)) = val_no_chroma;
734 if (
ctx->alpha_info && pic->
data[3] && a_data_size) {
737 buf + y_data_size + u_data_size + v_data_size,
753 for (
i = 0;
i <
ctx->slice_count;
i++)
758 if (error < ctx->slice_count)
761 return ctx->slices[0].ret;
768 const uint8_t *buf = avpkt->
data;
769 int buf_size = avpkt->
size;
770 int frame_hdr_size, pic_size,
ret;
778 ctx->first_field = 1;
784 if (frame_hdr_size < 0)
785 return frame_hdr_size;
787 buf += frame_hdr_size;
788 buf_size -= frame_hdr_size;
821 buf_size -= pic_size;
823 if (
ctx->frame_type && buf_size > 0 &&
ctx->first_field) {
824 ctx->first_field = 0;
869 #if CONFIG_PRORES_VIDEOTOOLBOX_HWACCEL
static void error(const char *err)
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
#define AV_LOG_WARNING
Something somehow does not look correct.
AVPixelFormat
Pixel format.
static int get_bits_left(GetBitContext *gb)
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
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
const AVProfile ff_prores_profiles[]
static int decode_frame_header(ProresContext *ctx, const uint8_t *buf, const int data_size, AVCodecContext *avctx)
static void unpack_alpha_10(GetBitContext *gb, uint16_t *dst, int num_coeffs, const int num_bits)
This structure describes decoded (raw) audio or video data.
static int decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *avpkt)
static int decode_picture_header(AVCodecContext *avctx, const uint8_t *buf, const int buf_size)
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
#define AV_PIX_FMT_YUVA422P10
const uint8_t ff_prores_progressive_scan[64]
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
#define AV_PROFILE_PRORES_STANDARD
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
av_cold void ff_permute_scantable(uint8_t dst[64], const uint8_t src[64], const uint8_t permutation[64])
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
#define AV_PROFILE_PRORES_HQ
AVCodec p
The public AVCodec.
enum AVPixelFormat pix_fmt
int flags
AV_CODEC_FLAG_*.
static double val(void *priv, double ch)
#define AV_PIX_FMT_YUV444P10
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static void decode_slice_alpha(const ProresContext *ctx, uint16_t *dst, int dst_stride, const uint8_t *buf, int buf_size, int blocks_per_slice)
Decode alpha slice plane.
#define AV_PROFILE_UNKNOWN
#define CLOSE_READER(name, gb)
static const uint8_t dc_codebook[7]
static void unpack_alpha_12(GetBitContext *gb, uint16_t *dst, int num_coeffs, const int num_bits)
#define FF_CODEC_DECODE_CB(func)
av_cold void ff_blockdsp_init(BlockDSPContext *c)
static av_cold int decode_close(AVCodecContext *avctx)
int flags
Flags modifying the (de)muxer behaviour.
static enum AVPixelFormat pix_fmt
int ff_thread_get_buffer(AVCodecContext *avctx, AVFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
#define SHOW_SBITS(name, gb, num)
static av_always_inline int decode_dc_coeffs(GetBitContext *gb, int16_t *out, int blocks_per_slice)
#define LOCAL_ALIGNED_16(t, v,...)
static enum AVPixelFormat pix_fmts[]
#define AV_PIX_FMT_YUVA444P12
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
#define SKIP_BITS(name, gb, num)
static int decode_slice_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
const uint8_t ff_prores_interlaced_scan[64]
#define CODEC_LONG_NAME(str)
static av_always_inline int decode_ac_coeffs(AVCodecContext *avctx, GetBitContext *gb, int16_t *out, int blocks_per_slice)
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
#define ALPHA_SHIFT_8_TO_10(alpha_val)
#define FF_DECODE_ERROR_INVALID_BITSTREAM
#define DECODE_CODEWORD(val, codebook, SKIP)
#define LOCAL_ALIGNED_32(t, v,...)
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
#define ALPHA_SHIFT_16_TO_10(alpha_val)
static unsigned int get_bits1(GetBitContext *s)
#define LAST_SKIP_BITS(name, gb, num)
#define UPDATE_THREAD_CONTEXT(func)
#define AV_PIX_FMT_YUV422P10
#define AV_PROFILE_PRORES_LT
static const uint8_t lev_to_cb[10]
int(* init)(AVBSFContext *ctx)
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
static int decode_slice_luma(AVCodecContext *avctx, SliceContext *slice, uint16_t *dst, int dst_stride, const uint8_t *buf, unsigned buf_size, const int16_t *qmat)
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
av_cold void ff_proresdsp_init(ProresDSPContext *dsp, int bits_per_raw_sample)
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
#define AV_PIX_FMT_YUV422P12
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
#define AV_PIX_FMT_YUV444P12
int skip_alpha
Skip processing alpha if supported by codec.
#define OPEN_READER(name, gb)
#define AV_PROFILE_PRORES_4444
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
#define AV_PIX_FMT_YUVA444P10
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 offset
#define AV_PROFILE_PRORES_PROXY
@ AV_PIX_FMT_VIDEOTOOLBOX
hardware decoding through Videotoolbox
#define i(width, name, range_min, range_max)
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
static int decode_slice_chroma(AVCodecContext *avctx, SliceContext *slice, uint16_t *dst, int dst_stride, const uint8_t *buf, unsigned buf_size, const int16_t *qmat, int log2_blocks_per_mb)
const char * name
Name of the codec implementation.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
void * av_calloc(size_t nmemb, size_t size)
#define HWACCEL_VIDEOTOOLBOX(codec)
const FFCodec ff_prores_decoder
#define ALPHA_SHIFT_16_TO_12(alpha_val)
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
static const uint8_t run_to_cb[16]
static const char * hwaccel
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call ff_thread_finish_setup() afterwards. If some code can 't be moved
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
main external API structure.
#define SHOW_UBITS(name, gb, num)
#define AV_PIX_FMT_YUVA422P12
static const FFHWAccel * ffhwaccel(const AVHWAccel *codec)
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have update_thread_context() run it in the next thread. Add AV_CODEC_CAP_FRAME_THREADS to the codec capabilities. There will be very little speed gain at this point but it should work. Use ff_thread_get_buffer()(or ff_progress_frame_get_buffer() in case you have inter-frame dependencies and use the ProgressFrame API) to allocate frame buffers. Call ff_progress_frame_report() after some part of the current picture has decoded. A good place to put this is where draw_horiz_band() is called - add this if it isn 't called anywhere
#define UPDATE_CACHE_32(name, gb)
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
#define ALPHA_SHIFT_8_TO_12(alpha_val)
This structure stores compressed data.
static void unpack_alpha(GetBitContext *gb, uint16_t *dst, int num_coeffs, const int num_bits, const int decode_precision)
int width
picture width / height.
#define AV_PROFILE_PRORES_XQ
#define flags(name, subs,...)
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
The exact code depends on how similar the blocks are and how related they are to the block
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
static int decode_picture(AVCodecContext *avctx)
#define MKTAG(a, b, c, d)
int(* execute2)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count)
The codec may call this to execute several independent things.
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
static av_cold int decode_init(AVCodecContext *avctx)