29 #define LONG_BITSTREAM_READER 43 for (i = 0; i < 64; i++)
44 dst[i] = permutation[src[i]];
74 ff_dlog(avctx,
"header size %d\n", hdr_size);
75 if (hdr_size > data_size) {
81 ff_dlog(avctx,
"%.4s version %d\n", buf+4, version);
89 if (width != avctx->
width || height != avctx->
height) {
122 ff_dlog(avctx,
"flags %x\n", flags);
125 if(buf + data_size - ptr < 64) {
136 if(buf + data_size - ptr < 64) {
151 int i, hdr_size, slice_count;
152 unsigned pic_data_size;
153 int log2_slice_mb_width, log2_slice_mb_height;
154 int slice_mb_count, mb_x, mb_y;
155 const uint8_t *data_ptr, *index_ptr;
157 hdr_size = buf[0] >> 3;
158 if (hdr_size < 8 || hdr_size > buf_size) {
163 pic_data_size =
AV_RB32(buf + 1);
164 if (pic_data_size > buf_size) {
169 log2_slice_mb_width = buf[7] >> 4;
170 log2_slice_mb_height = buf[7] & 0xF;
171 if (log2_slice_mb_width > 3 || log2_slice_mb_height) {
173 1 << log2_slice_mb_width, 1 << log2_slice_mb_height);
186 av_popcount(ctx->
mb_width & (1 << log2_slice_mb_width) - 1));
200 if (hdr_size + slice_count*2 > buf_size) {
206 index_ptr = buf + hdr_size;
207 data_ptr = index_ptr + slice_count*2;
209 slice_mb_count = 1 << log2_slice_mb_width;
213 for (i = 0; i < slice_count; i++) {
216 slice->
data = data_ptr;
217 data_ptr +=
AV_RB16(index_ptr + i*2);
219 while (ctx->
mb_width - mb_x < slice_mb_count)
220 slice_mb_count >>= 1;
232 mb_x += slice_mb_count;
234 slice_mb_count = 1 << log2_slice_mb_width;
238 if (data_ptr > buf + buf_size) {
250 return pic_data_size;
253 #define DECODE_CODEWORD(val, codebook, SKIP) \ 255 unsigned int rice_order, exp_order, switch_bits; \ 256 unsigned int q, buf, bits; \ 258 UPDATE_CACHE(re, gb); \ 259 buf = GET_CACHE(re, gb); \ 262 switch_bits = codebook & 3; \ 263 rice_order = codebook >> 5; \ 264 exp_order = (codebook >> 2) & 7; \ 266 q = 31 - av_log2(buf); \ 268 if (q > switch_bits) { \ 269 bits = exp_order - switch_bits + (q<<1); \ 270 if (bits > FFMIN(MIN_CACHE_BITS, 31)) \ 271 return AVERROR_INVALIDDATA; \ 272 val = SHOW_UBITS(re, gb, bits) - (1 << exp_order) + \ 273 ((switch_bits + 1) << rice_order); \ 274 SKIP(re, gb, bits); \ 275 } else if (rice_order) { \ 276 SKIP_BITS(re, gb, q+1); \ 277 val = (q << rice_order) + SHOW_UBITS(re, gb, rice_order); \ 278 SKIP(re, gb, rice_order); \ 285 #define TOSIGNED(x) (((x) >> 1) ^ (-((x) & 1))) 287 #define FIRST_DC_CB 0xB8 292 int blocks_per_slice)
307 for (i = 1; i < blocks_per_slice; i++, out += 64) {
309 if(code) sign ^= -(code & 1);
311 prev_dc += (((code + 1) >> 1) ^ sign) - sign;
319 static const uint8_t run_to_cb[16] = { 0x06, 0x06, 0x05, 0x05, 0x04, 0x29, 0x29, 0x29, 0x29, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x4C };
320 static const uint8_t lev_to_cb[10] = { 0x04, 0x0A, 0x05, 0x06, 0x04, 0x28, 0x28, 0x28, 0x28, 0x4C };
323 int16_t *
out,
int blocks_per_slice)
326 int block_mask, sign;
328 int max_coeffs, i, bits_left;
329 int log2_block_count =
av_log2(blocks_per_slice);
336 max_coeffs = 64 << log2_block_count;
337 block_mask = blocks_per_slice - 1;
339 for (pos = block_mask;;) {
341 if (!bits_left || (bits_left < 32 && !
SHOW_UBITS(
re, gb, bits_left)))
346 if (pos >= max_coeffs) {
354 i = pos >> log2_block_count;
358 out[((pos & block_mask) << 6) + ctx->
scan[i]] = ((level ^ sign) - sign);
366 uint16_t *dst,
int dst_stride,
374 int i, blocks_per_slice = slice->
mb_count<<2;
377 for (i = 0; i < blocks_per_slice; i++)
388 for (i = 0; i < slice->
mb_count; i++) {
391 ctx->
prodsp.
idct_put(dst+4*dst_stride , dst_stride, block+(2<<6), qmat);
392 ctx->
prodsp.
idct_put(dst+4*dst_stride+8, dst_stride, block+(3<<6), qmat);
400 uint16_t *dst,
int dst_stride,
402 const int16_t *qmat,
int log2_blocks_per_mb)
408 int i, j, blocks_per_slice = slice->
mb_count << log2_blocks_per_mb;
411 for (i = 0; i < blocks_per_slice; i++)
422 for (i = 0; i < slice->
mb_count; i++) {
423 for (j = 0; j < log2_blocks_per_mb; j++) {
425 ctx->
prodsp.
idct_put(dst+4*dst_stride, dst_stride, block+(1<<6), qmat);
436 const int mask = (1 << num_bits) - 1;
437 int i, idx,
val, alpha_val;
447 val =
get_bits(gb, num_bits == 16 ? 7 : 4);
449 val = (val + 2) >> 1;
453 alpha_val = (alpha_val +
val) & mask;
454 if (num_bits == 16) {
455 dst[idx++] = alpha_val >> 6;
457 dst[idx++] = (alpha_val << 2) | (alpha_val >> 6);
459 if (idx >= num_coeffs)
465 if (idx + val > num_coeffs)
466 val = num_coeffs - idx;
467 if (num_bits == 16) {
468 for (i = 0; i <
val; i++)
469 dst[idx++] = alpha_val >> 6;
471 for (i = 0; i <
val; i++)
472 dst[idx++] = (alpha_val << 2) | (alpha_val >> 6);
475 }
while (idx < num_coeffs);
482 uint16_t *dst,
int dst_stride,
484 int blocks_per_slice)
491 for (i = 0; i < blocks_per_slice<<2; i++)
497 unpack_alpha(&gb, blocks, blocks_per_slice * 4 * 64, 16);
499 unpack_alpha(&gb, blocks, blocks_per_slice * 4 * 64, 8);
503 for (i = 0; i < 16; i++) {
504 memcpy(dst, block, 16 * blocks_per_slice *
sizeof(*dst));
505 dst += dst_stride >> 1;
506 block += 16 * blocks_per_slice;
516 int i, hdr_size, qscale, log2_chroma_blocks_per_mb;
517 int luma_stride, chroma_stride;
518 int y_data_size, u_data_size, v_data_size, a_data_size;
519 uint8_t *dest_y, *dest_u, *dest_v, *dest_a;
530 hdr_size = buf[0] >> 3;
531 qscale = av_clip(buf[1], 1, 224);
532 qscale = qscale > 128 ? qscale - 96 << 2: qscale;
533 y_data_size =
AV_RB16(buf + 2);
534 u_data_size =
AV_RB16(buf + 4);
535 v_data_size = slice->
data_size - y_data_size - u_data_size - hdr_size;
536 if (hdr_size > 7) v_data_size =
AV_RB16(buf + 6);
537 a_data_size = slice->
data_size - y_data_size - u_data_size -
538 v_data_size - hdr_size;
540 if (y_data_size < 0 || u_data_size < 0 || v_data_size < 0
541 || hdr_size+y_data_size+u_data_size+v_data_size > slice->
data_size){
548 for (i = 0; i < 64; i++) {
549 qmat_luma_scaled [i] = ctx->
qmat_luma [i] * qscale;
550 qmat_chroma_scaled[i] = ctx->
qmat_chroma[i] * qscale;
557 luma_stride = pic->
linesize[0] << 1;
558 chroma_stride = pic->
linesize[1] << 1;
563 log2_chroma_blocks_per_mb = 2;
566 log2_chroma_blocks_per_mb = 1;
569 dest_y = pic->
data[0] + (slice->
mb_y << 4) * luma_stride + (slice->
mb_x << 5);
570 dest_u = pic->
data[1] + (slice->
mb_y << 4) * chroma_stride + (slice->
mb_x << mb_x_shift);
571 dest_v = pic->
data[2] + (slice->
mb_y << 4) * chroma_stride + (slice->
mb_x << mb_x_shift);
572 dest_a = pic->
data[3] + (slice->
mb_y << 4) * luma_stride + (slice->
mb_x << 5);
582 buf, y_data_size, qmat_luma_scaled);
588 buf + y_data_size, u_data_size,
589 qmat_chroma_scaled, log2_chroma_blocks_per_mb);
594 buf + y_data_size + u_data_size, v_data_size,
595 qmat_chroma_scaled, log2_chroma_blocks_per_mb);
600 size_t mb_max_x = slice->
mb_count << (mb_x_shift - 1);
602 for (i = 0; i < 16; ++i)
603 for (j = 0; j < mb_max_x; ++j) {
604 *(uint16_t*)(dest_u + (i * chroma_stride) + (j << 1)) = 511;
605 *(uint16_t*)(dest_v + (i * chroma_stride) + (j << 1)) = 511;
612 buf + y_data_size + u_data_size + v_data_size,
632 if (error < ctx->slice_count)
644 int buf_size = avpkt->
size;
645 int frame_hdr_size, pic_size, ret;
661 if (frame_hdr_size < 0)
662 return frame_hdr_size;
664 buf += frame_hdr_size;
665 buf_size -= frame_hdr_size;
683 buf_size -= pic_size;
const char const char void * val
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
This structure describes decoded (raw) audio or video data.
#define AV_PIX_FMT_YUVA422P10
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
static av_cold int init(AVCodecContext *avctx)
static int decode_slice_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
void(* clear_block)(int16_t *block)
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)
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
uint8_t qmat_chroma[64]
dequantization matrix for chroma
av_cold void ff_proresdsp_init(ProresDSPContext *dsp, AVCodecContext *avctx)
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
unsigned mb_height
height of the current picture in mb
int idct_permutation_type
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
static int decode_picture_header(AVCodecContext *avctx, const uint8_t *buf, const int buf_size)
static av_cold int decode_init(AVCodecContext *avctx)
AVCodec ff_prores_decoder
bitstream reader API header.
int interlaced_frame
The content of the picture is interlaced.
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
int slice_count
number of slices in the current picture
static int get_bits_left(GetBitContext *gb)
unsigned mb_width
width of the current picture in mb
#define UPDATE_CACHE(name, gb)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static const uint16_t mask[17]
int skip_alpha
Skip processing alpha if supported by codec.
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
int flags
AV_CODEC_FLAG_*.
const char * name
Name of the codec implementation.
#define AV_PIX_FMT_YUV444P10
#define CLOSE_READER(name, gb)
#define SKIP_BITS(name, gb, num)
common internal API header
enum AVPictureType pict_type
Picture type of the frame.
av_cold void ff_init_scantable_permutation(uint8_t *idct_permutation, enum idct_permutation_type perm_type)
int width
picture width / height.
uint8_t idct_permutation[64]
#define LAST_SKIP_BITS(name, gb, num)
static const uint8_t lev_to_cb[10]
#define AV_PIX_FMT_YUVA444P10
uint8_t interlaced_scan[64]
static void error(const char *err)
#define SHOW_UBITS(name, gb, num)
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
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.
const uint8_t ff_prores_interlaced_scan[64]
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
main external API structure.
const uint8_t ff_prores_progressive_scan[64]
static void permute(uint8_t *dst, const uint8_t *src, const uint8_t permutation[64])
#define OPEN_READER(name, gb)
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
static av_always_inline int decode_ac_coeffs(AVCodecContext *avctx, GetBitContext *gb, int16_t *out, int blocks_per_slice)
static unsigned int get_bits1(GetBitContext *s)
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)
static const uint8_t run_to_cb[16]
uint8_t progressive_scan[64]
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
#define DECODE_CODEWORD(val, codebook, SKIP)
#define FF_DECODE_ERROR_INVALID_BITSTREAM
int decode_error_flags
decode error flags of the frame, set to a combination of FF_DECODE_ERROR_xxx flags if the decoder pro...
#define AV_PIX_FMT_YUV422P10
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static void unpack_alpha(GetBitContext *gb, uint16_t *dst, int num_coeffs, const int num_bits)
#define LOCAL_ALIGNED_32(t, v,...)
#define SHOW_SBITS(name, gb, num)
common internal api header.
static const uint8_t dc_codebook[7]
int top_field_first
If the content is interlaced, is top field displayed first.
static void decode_slice_alpha(ProresContext *ctx, uint16_t *dst, int dst_stride, const uint8_t *buf, int buf_size, int blocks_per_slice)
Decode alpha slice plane.
int key_frame
1 -> keyframe, 0-> not
static int decode_frame_header(ProresContext *ctx, const uint8_t *buf, const int data_size, AVCodecContext *avctx)
static av_always_inline int decode_dc_coeffs(GetBitContext *gb, int16_t *out, int blocks_per_slice)
static av_cold int decode_close(AVCodecContext *avctx)
#define LOCAL_ALIGNED_16(t, v,...)
uint8_t qmat_luma[64]
dequantization matrix for luma
int frame_type
0 = progressive, 1 = tff, 2 = bff
This structure stores compressed data.
static int decode_picture(AVCodecContext *avctx)
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
void(* idct_put)(uint16_t *out, ptrdiff_t linesize, int16_t *block, const int16_t *qmat)
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().