77 0, 1818, 3622, 4144, 4698, 5234, 5804, 5868, 5900, 5932,
78 5996, 6252, 6316, 6348, 6380, 7674, 8944, 10274, 11668, 12250,
79 14060, 15846, 16372, 16962, 17512, 18148, 18180, 18212, 18244, 18308,
80 18564, 18628, 18660, 18692, 20036, 21314, 22648, 23968, 24614, 26384,
81 28190, 28736, 29366, 29938, 30608, 30640, 30672, 30704, 30768, 31024,
82 31088, 31120, 31184, 32570, 33898, 35236, 36644, 37286, 39020, 40802,
83 41368, 42052, 42692, 43348, 43380, 43412, 43444, 43476, 43604, 43668,
84 43700, 43732, 45100, 46430, 47778, 49160, 49802, 51550, 53340, 53972,
85 54648, 55348, 55994, 56122, 56154, 56186, 56218, 56346, 56410, 56442,
86 56474, 57878, 59290, 60636, 62036, 62682, 64460, 64524, 64588, 64716,
87 64844, 66076, 67466, 67978, 68542, 69064, 69648, 70296, 72010, 72074,
88 72138, 72202, 72330, 73572, 74936, 75454, 76030, 76566, 77176, 77822,
89 79582, 79646, 79678, 79742, 79870, 81180, 82536, 83064, 83672, 84242,
90 84934, 85576, 87384, 87448, 87480, 87544, 87672, 88982, 90340, 90902,
91 91598, 92182, 92846, 93488, 95246, 95278, 95310, 95374, 95502, 96878,
92 98266, 98848, 99542, 100234, 100884, 101524, 103320, 103352, 103384, 103416,
93 103480, 104874, 106222, 106910, 107584, 108258, 108902, 109544, 111366, 111398,
94 111430, 111462, 111494, 112878, 114320, 114988, 115660, 116310, 116950, 117592
111 int counts[17] = {0}, codes[17];
114 int maxbits = 0, realsize = 0;
116 for(i = 0; i <
size; i++){
118 bits2[realsize] = bits[i];
119 syms[realsize] = insyms ? insyms[i] : i;
121 maxbits =
FFMAX(maxbits, bits[i]);
127 for(i = 0; i < 16; i++)
128 codes[i+1] = (codes[i] + counts[i]) << 1;
129 for(i = 0; i < realsize; i++)
130 cw[i] = codes[bits2[i]]++;
148 for(j = 0; j < 2; j++){
152 for(k = 0; k < 4; k++){
156 for(j = 0; j < 4; j++){
164 for(j = 0; j < 4; j++){
167 for(j = 0; j < 2; j++){
188 int pattern, code, cbp=0;
190 static const int cbp_masks[3] = {0x100000, 0x010000, 0x110000};
191 static const int shifts[4] = { 0, 2, 8, 10 };
192 const int *curshift = shifts;
196 pattern = code & 0xF;
201 for(mask = 8;
mask; mask >>= 1, curshift++){
206 for(i = 0; i < 4; i++){
211 cbp |= cbp_masks[2] << i;
226 coef = 22 + ((1 << coef) |
get_bits(gb, coef));
232 *dst = (coef*q + 8) >> 4;
245 decode_coeff(dst+1*4+0, (flags >> 4) & 3, 2, gb, vlc, q);
246 decode_coeff(dst+0*4+1, (flags >> 2) & 3, 2, gb, vlc, q);
248 decode_coeff(dst+0*4+1, (flags >> 4) & 3, 2, gb, vlc, q);
249 decode_coeff(dst+1*4+0, (flags >> 2) & 3, 2, gb, vlc, q);
251 decode_coeff( dst+1*4+1, (flags >> 0) & 3, 2, gb, vlc, q);
264 int q_dc,
int q_ac1,
int q_ac2)
268 decode_coeff(dst+0*4+0, (flags >> 6) , 3, gb, vlc, q_dc);
269 decode_coeff(dst+0*4+1, (flags >> 4) & 3, 2, gb, vlc, q_ac1);
270 decode_coeff(dst+1*4+0, (flags >> 2) & 3, 2, gb, vlc, q_ac1);
271 decode_coeff(dst+1*4+1, (flags >> 0) & 3, 2, gb, vlc, q_ac2);
287 int code, pattern, has_ac = 1;
291 pattern = code & 0x7;
316 return has_ac | pattern;
331 for(i = 0; i < 5; i++)
342 if(mod == 2 && quant < 19) quant += 10;
343 else if(mod && quant < 26) quant += 5;
426 for(i = 0; i < 16; i++)
448 static const uint8_t part_sizes_w[
RV34_MB_TYPES] = { 2, 2, 2, 1, 2, 2, 2, 2, 2, 1, 2, 2 };
451 static const uint8_t part_sizes_h[
RV34_MB_TYPES] = { 2, 2, 2, 1, 2, 2, 2, 2, 1, 2, 2, 2 };
467 int A[2] = {0},
B[2], C[2];
473 mv_pos += (subblock_no & 1) + (subblock_no >> 1)*s->
b8_stride;
489 if(avail[-4] && (avail[-1] || r->
rv30)){
502 mx += r->
dmv[dmv_no][0];
503 my += r->
dmv[dmv_no][1];
512 #define GET_PTS_DIFF(a, b) ((a - b + 8192) & 0x1FFF)
521 return (val * mul + 0x2000) >> 14;
528 int A_avail,
int B_avail,
int C_avail,
531 if(A_avail + B_avail + C_avail != 3){
532 *mx = A[0] + B[0] + C[0];
533 *my = A[1] + B[1] + C[1];
534 if(A_avail + B_avail + C_avail == 2){
552 int A[2] = { 0 },
B[2] = { 0 }, C[2] = { 0 };
553 int has_A = 0, has_B = 0, has_C = 0;
558 int type = cur_pic->
f.
mb_type[mb_pos];
582 mx += r->
dmv[dir][0];
583 my += r->
dmv[dir][1];
585 for(j = 0; j < 2; j++){
586 for(i = 0; i < 2; i++){
603 int A[2] = {0},
B[2], C[2];
620 if(avail[-4] && (avail[-1])){
635 for(j = 0; j < 2; j++){
636 for(i = 0; i < 2; i++){
637 for(k = 0; k < 2; k++){
663 const int xoff,
const int yoff,
int mv_off,
665 const int thirdpel,
int weighted,
671 int dxy, mx, my, umx, umy, lx, ly, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
676 int chroma_mx, chroma_my;
683 umx = (chroma_mx + (3 << 24)) / 3 - (1 << 24);
684 umy = (chroma_my + (3 << 24)) / 3 - (1 << 24);
697 uvmx = (cx & 3) << 1;
698 uvmy = (cy & 3) << 1;
700 if(uvmx == 6 && uvmy == 6)
706 int mb_row = s->
mb_y + ((yoff + my + 5 + 8 *
height) >> 4);
715 src_x = s->
mb_x * 16 + xoff + mx;
716 src_y = s->
mb_y * 16 + yoff + my;
717 uvsrc_x = s->
mb_x * 8 + (xoff >> 1) + umx;
718 uvsrc_y = s->
mb_y * 8 + (yoff >> 1) + umy;
719 srcY += src_y * s->
linesize + src_x;
723 (
unsigned)(src_x - !!lx*2) > s->
h_edge_pos - !!lx*2 - (width <<3) - 4 ||
724 (unsigned)(src_y - !!ly*2) > s->
v_edge_pos - !!ly*2 - (height<<3) - 4) {
758 qpel_mc[!is16x16][dxy](
Y, srcY, s->
linesize);
764 const int xoff,
const int yoff,
int mv_off,
765 const int width,
const int height,
int dir)
767 rv34_mc(r, block_type, xoff, yoff, mv_off, width, height, dir, r->
rv30, 0,
798 rv34_mc(r, block_type, 0, 0, 0, 2, 2, 0, r->
rv30, weighted,
802 rv34_mc(r, block_type, 0, 0, 0, 2, 2, 1, r->
rv30, 0,
806 rv34_mc(r, block_type, 0, 0, 0, 2, 2, 1, r->
rv30, 1,
818 for(j = 0; j < 2; j++)
819 for(i = 0; i < 2; i++){
834 static const int num_mvs[
RV34_MB_TYPES] = { 0, 0, 1, 4, 1, 1, 0, 0, 2, 2, 2, 1 };
848 memset(r->
dmv, 0,
sizeof(r->
dmv));
849 for(i = 0; i < num_mvs[block_type]; i++){
875 for(j = 0; j < 2; j++)
876 for(i = 0; i < 2; i++)
877 for(k = 0; k < 2; k++)
878 for(l = 0; l < 2; l++)
893 r->
dmv[1][0] = r->
dmv[0][0];
894 r->
dmv[1][1] = r->
dmv[0][1];
951 uint8_t *prev = dst - stride + 4;
970 topleft = dst[-stride + 3] * 0x01010101u;
994 int fc,
int sc,
int q_dc,
int q_ac)
999 fc, sc, q_dc, q_ac, q_ac);
1017 int i, j, itype, has_ac;
1019 memset(block16, 0, 16 *
sizeof(*block16));
1027 itype = ittrans16[intra_types[0]];
1031 for(j = 0; j < 4; j++){
1032 for(i = 0; i < 4; i++, cbp >>= 1){
1033 int dc = block16[i + j*4];
1050 itype = ittrans16[intra_types[0]];
1057 for(j = 1; j < 3; j++){
1060 for(i = 0; i < 4; i++, cbp >>= 1){
1062 if(!(cbp & 1))
continue;
1063 pdst = dst + (i&1)*4 + (i&2)*2*s->
uvlinesize;
1075 int avail[6*8] = {0};
1077 int idx, q_ac, q_dc;
1083 avail[1] = avail[2] = 1;
1085 avail[3] = avail[4] = 1;
1089 avail[8] = avail[16] = 1;
1091 avail[24] = avail[32] = 1;
1094 for(j = 0; j < 4; j++){
1096 for(i = 0; i < 4; i++, cbp >>= 1, dst += 4, idx++){
1099 if(!(cbp & 1))
continue;
1113 for(k = 0; k < 2; k++){
1117 for(j = 0; j < 2; j++){
1119 for(i = 0; i < 2; i++, cbp >>= 1, acache++){
1124 if(!(cbp&1))
continue;
1138 d = motion_val[0][0] - motion_val[-
step][0];
1141 d = motion_val[0][1] - motion_val[-
step][1];
1150 int hmvmask = 0, vmvmask = 0, i, j;
1153 for(j = 0; j < 16; j += 8){
1154 for(i = 0; i < 2; i++){
1156 vmvmask |= 0x11 << (j + i*2);
1158 hmvmask |= 0x03 << (j + i*2);
1167 vmvmask |= (vmvmask & 0x4444) >> 1;
1168 hmvmask |= (hmvmask & 0x0F00) >> 4;
1174 return hmvmask | vmvmask;
1185 int q_dc, q_ac, has_ac;
1223 memset(block16, 0, 16 *
sizeof(*block16));
1233 for(j = 0; j < 4; j++){
1234 for(i = 0; i < 4; i++, cbp >>= 1){
1235 int dc = block16[i + j*4];
1256 for(j = 0; j < 4; j++){
1257 for(i = 0; i < 4; i++, cbp >>= 1){
1258 if(!(cbp & 1))
continue;
1270 for(j = 1; j < 3; j++){
1272 for(i = 0; i < 4; i++, cbp >>= 1){
1274 if(!(cbp & 1))
continue;
1275 pdst = dst + (i&1)*4 + (i&2)*2*s->
uvlinesize;
1335 if(bits < 0 || (bits < 8 && !
show_bits(&s->
gb, bits)))
1391 int mb_pos, slice_type;
1491 #if CONFIG_RV30_DECODER
1495 #if CONFIG_RV40_DECODER
1503 if(!intra_vlcs[0].cbppattern[0].
bits)
1532 if (dst == src || !
s1->context_initialized)
1551 memset(&r->
si, 0,
sizeof(r->
si));
1566 int got_picture = 0;
1589 void *
data,
int *got_picture_ptr,
1593 int buf_size = avpkt->
size;
1604 if (buf_size == 0) {
1610 *got_picture_ptr = 1;
1616 slice_count = (*buf++) + 1;
1617 slices_hdr = buf + 4;
1618 buf += 8 * slice_count;
1619 buf_size -= 1 + 8 * slice_count;
1637 "reference data.\n");
1646 if (si.
start == 0) {
1676 for (i = 0; i < 2; i++)
1679 for (i = 0; i < 4; i++)
1715 "multithreading mode (start MB is %d).\n", si.
start);
1719 for(i = 0; i < slice_count; i++){
1722 if(i+1 == slice_count)
1723 size = buf_size - offset;
1727 if(offset < 0 || offset > buf_size){
1735 if(i+1 < slice_count){
1743 if(i+2 < slice_count)
1746 size = buf_size - offset;
1750 if (size < 0 || size > buf_size - offset) {
qpel_mc_func put_pixels_tab[4][16]
P-frame macroblock with DCs in a separate 4x4 block, one motion vector.
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
int vlc_set
VLCs used for this slice.
VLC second_pattern[2]
VLCs used for decoding coefficients in the subblocks 2 and 3.
discard all frames except keyframes
void ff_init_block_index(MpegEncContext *s)
static const uint8_t rv34_table_inter_secondpat[NUM_INTER_TABLES][2][OTHERBLK_VLC_SIZE]
P-frame macroblock, 16x8 motion compensation partitions.
This structure describes decoded (raw) audio or video data.
static void rv34_output_i16x16(RV34DecContext *r, int8_t *intra_types, int cbp)
uint8_t * tmp_b_block_y[2]
temporary blocks for RV4 weighted MC
int(* decode_intra_types)(struct RV34DecContext *r, GetBitContext *gb, int8_t *dst)
void(* loop_filter)(struct RV34DecContext *r, int row)
uint32_t avail_cache[3 *4]
8x8 block available flags (for MV prediction)
av_cold int ff_MPV_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
static const int ittrans[9]
mapping of RV30/40 intra prediction types to standard H.264 types
B-frame macroblock, forward prediction.
int dmv[4][2]
differential motion vectors for the current macroblock
Bidirectionally predicted B-frame macroblock, two motion vectors.
static int rv34_decode_intra_mb_header(RV34DecContext *r, int8_t *intra_types)
Decode intra macroblock header and return CBP in case of success, -1 otherwise.
int v_edge_pos
horizontal / vertical position of the right/bottom edge (pixel replication)
void ff_er_frame_end(ERContext *s)
static const uint8_t rv34_chroma_quant[2][32]
quantizer values used for AC and DC coefficients in chroma blocks
void avcodec_set_dimensions(AVCodecContext *s, int width, int height)
Bidirectionally predicted B-frame macroblock, no motion vectors.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
static int rv34_decode_mv(RV34DecContext *r, int block_type)
Decode motion vector differences and perform motion vector reconstruction and motion compensation...
static void rv34_pred_b_vector(int A[2], int B[2], int C[2], int A_avail, int B_avail, int C_avail, int *mx, int *my)
Predict motion vector for B-frame macroblock.
VLC cbppattern[2]
VLCs used for pattern of coded block patterns decoding.
static int finish_frame(AVCodecContext *avctx, AVFrame *pict)
int weight2
B frame distance fractions (0.14) used in motion compensation.
#define GET_PTS_DIFF(a, b)
RV30 and RV40 decoder common data declarations.
static int rv34_decode_slice(RV34DecContext *r, int end, const uint8_t *buf, int buf_size)
static void rv34_pred_4x4_block(RV34DecContext *r, uint8_t *dst, int stride, int itype, int up, int left, int down, int right)
Perform 4x4 intra prediction.
static const int rv34_mb_type_to_lavc[12]
translation of RV30/40 macroblock types to lavc ones
#define DIAG_DOWN_LEFT_PRED_RV40_NODOWN
const uint8_t * luma_dc_quant_p
luma subblock DC quantizer for interframes
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
enum AVDiscard skip_frame
uint8_t * tmp_b_block_base
int mb_num_left
number of MBs left in this video packet (for partitioned Slices only)
void(* emulated_edge_mc)(uint8_t *buf, const uint8_t *src, ptrdiff_t linesize, int block_w, int block_h, int src_x, int src_y, int w, int h)
Copy a rectangular area of samples to a temporary buffer and replicate the border samples...
static void rv34_gen_vlc(const uint8_t *bits, int size, VLC *vlc, const uint8_t *insyms, const int num)
Generate VLC from codeword lengths.
int ff_MPV_common_frame_size_change(MpegEncContext *s)
int ff_init_vlc_sparse(VLC *vlc, int nb_bits, int nb_codes, const void *bits, int bits_wrap, int bits_size, const void *codes, int codes_wrap, int codes_size, const void *symbols, int symbols_wrap, int symbols_size, int flags)
static void rv34_process_block(RV34DecContext *r, uint8_t *pdst, int stride, int fc, int sc, int q_dc, int q_ac)
static const uint8_t rv34_table_intra_firstpat[NUM_INTRA_TABLES][4][FIRSTBLK_VLC_SIZE]
uint16_t * cbp_luma
CBP values for luma subblocks.
static const uint16_t rv34_mb_max_sizes[6]
maximum number of macroblocks for each of the possible slice offset sizes
enum OutputFormat out_format
output format
static const int chroma_coeffs[3]
static void rv34_mc_2mv_skip(RV34DecContext *r)
void(* qpel_mc_func)(uint8_t *dst, uint8_t *src, int stride)
#define HOR_UP_PRED_RV40_NODOWN
void ff_mpeg_er_frame_start(MpegEncContext *s)
#define DIAG_DOWN_LEFT_PRED
#define MB_TYPE_SEPARATE_DC
rv40_weight_func rv40_weight_pixels_tab[2][2]
Biweight functions, first dimension is transform size (16/8), second is whether the weight is prescal...
uint16_t * deblock_coefs
deblock coefficients for each macroblock
void(* pred8x8[4+3+4])(uint8_t *src, ptrdiff_t stride)
static const uint8_t part_sizes_h[RV34_MB_TYPES]
macroblock partition height in 8x8 blocks
static RV34VLC inter_vlcs[NUM_INTER_TABLES]
static void decode_subblock(DCTELEM *dst, int code, const int is_block2, GetBitContext *gb, VLC *vlc, int q)
Decode 2x2 subblock of coefficients.
static const uint8_t bits2[81]
static int is_mv_diff_gt_3(int16_t(*motion_val)[2], int step)
static VLC_TYPE table_data[117592][2]
int mb_height
number of MBs horizontally & vertically
static const uint16_t rv34_qscale_tab[32]
This table is used for dequantizing.
#define LOCAL_ALIGNED_16(t, v,...)
void ff_MPV_frame_end(MpegEncContext *s)
static void rv34_output_intra(RV34DecContext *r, int8_t *intra_types, int cbp)
void(* pred4x4[9+3+3])(uint8_t *src, const uint8_t *topright, ptrdiff_t stride)
rv34_idct_add_func rv34_idct_add
P-frame macroblock, 8x16 motion compensation partitions.
static void ff_update_block_index(MpegEncContext *s)
static const uint8_t rv34_quant_to_vlc_set[2][31]
tables used to translate a quantizer value into a VLC set for decoding The first table is used for in...
int slice_count
slice count
int quant
quantizer used for this slice
static int get_bits_left(GetBitContext *gb)
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...
static const int table_offs[]
void ff_h264_pred_init(H264PredContext *h, int codec_id, const int bit_depth, const int chroma_format_idc)
Set the intra prediction function pointers.
qpel_mc_func avg_pixels_tab[4][16]
int(* parse_slice_header)(struct RV34DecContext *r, GetBitContext *gb, SliceInfo *si)
int has_b_frames
Size of the frame reordering buffer in the decoder.
static void rv4_weight(RV34DecContext *r)
static const int ittrans16[4]
mapping of RV30/40 intra 16x16 prediction types to standard H.264 types
void ff_er_add_slice(ERContext *s, int startx, int starty, int endx, int endy, int status)
Add a slice.
Multithreading support functions.
static const uint16_t mask[17]
int is_copy
Whether the parent AVCodecContext is a copy of the context which had init() called on it...
rv34_idct_dc_add_func rv34_idct_dc_add
int active_thread_type
Which multithreading methods are in use by the codec.
static void rv34_mc_2mv(RV34DecContext *r, const int block_type)
static void rv34_pred_mv(RV34DecContext *r, int block_type, int subblock_no, int dmv_no)
motion vector prediction
int luma_vlc
which VLC set will be used for decoding of luma blocks
uint8_t * edge_emu_buffer
temporary buffer for if MVs point to out-of-frame data
void av_log(void *avcl, int level, const char *fmt,...)
static int rv34_decoder_realloc(RV34DecContext *r)
void(* h264_chroma_mc_func)(uint8_t *dst, uint8_t *src, int srcStride, int h, int x, int y)
int low_delay
no reordering needed / has no b-frames
#define CODEC_FLAG_EMU_EDGE
static void decode_subblock3(DCTELEM *dst, int code, GetBitContext *gb, VLC *vlc, int q_dc, int q_ac1, int q_ac2)
rv34_inv_transform_func rv34_inv_transform_dc
VLC tables used by the decoder.
int end
start and end macroblocks of the slice
int resync_mb_x
x position of last resync marker
static int svq3_get_se_golomb(GetBitContext *gb)
static int rv34_decode_block(DCTELEM *dst, GetBitContext *gb, RV34VLC *rvlc, int fc, int sc, int q_dc, int q_ac1, int q_ac2)
Decode coefficients for 4x4 block.
static int rv34_set_deblock_coef(RV34DecContext *r)
common internal API header
useful rectangle filling function
static void ZERO8x2(void *dst, int stride)
Intra macroblock with DCs in a separate 4x4 block.
static void rv34_pred_mv_b(RV34DecContext *r, int block_type, int dir)
motion vector prediction for B-frames
int * mb_type
internal macroblock types
static int adjust_pred16(int itype, int up, int left)
int width
picture width / height.
Picture * current_picture_ptr
pointer to the current picture
static int calc_add_mv(RV34DecContext *r, int dir, int val)
Calculate motion vector component that should be added for direct blocks.
H264PredContext h
functions for 4x4 and 16x16 intra block prediction
static RV34VLC * choose_vlc_set(int quant, int mod, int type)
Select VLC set for decoding from current quantizer, modifier and frame type.
VLC coefficient
VLCs used for decoding big coefficients.
static int rv34_decoder_alloc(RV34DecContext *r)
VLC first_pattern[4]
VLCs used for decoding coefficients in the first subblock.
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
static void fill_rectangle(SDL_Surface *screen, int x, int y, int w, int h, int color)
#define FIRSTBLK_VLC_SIZE
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
static const uint8_t rv34_table_intra_secondpat[NUM_INTRA_TABLES][2][OTHERBLK_VLC_SIZE]
static const uint8_t rv34_table_intra_thirdpat[NUM_INTRA_TABLES][2][OTHERBLK_VLC_SIZE]
static const uint8_t rv34_inter_coeff[NUM_INTER_TABLES][COEFF_VLC_SIZE]
int ff_MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
generic function for encode/decode called after coding/decoding the header and before a frame is code...
#define INIT_VLC_USE_NEW_STATIC
int ff_mpeg_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
#define VERT_PRED
Prediction types.
#define DIAG_DOWN_RIGHT_PRED
static void rv34_mc_1mv(RV34DecContext *r, const int block_type, const int xoff, const int yoff, int mv_off, const int width, const int height, int dir)
uint32_t * mb_type
macroblock type table mb_type_base + mb_width + 2
int first_slice_line
used in mpeg4 too to handle resync markers
static const uint8_t rv34_inter_cbp[NUM_INTER_TABLES][4][CBP_VLC_SIZE]
int ff_rv34_decode_init_thread_copy(AVCodecContext *avctx)
static void rv34_mc(RV34DecContext *r, const int block_type, const int xoff, const int yoff, int mv_off, const int width, const int height, int dir, const int thirdpel, int weighted, qpel_mc_func(*qpel_mc)[16], h264_chroma_mc_func(*chroma_mc))
generic motion compensation function
static int rv34_decode_intra_macroblock(RV34DecContext *r, int8_t *intra_types)
static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
essential slice information
void ff_thread_await_progress(AVFrame *f, int n, int field)
Wait for earlier decoding threads to finish reference pictures.
static const uint8_t rv34_table_inter_firstpat[NUM_INTER_TABLES][2][FIRSTBLK_VLC_SIZE]
static const uint8_t rv34_table_intra_cbppat[NUM_INTRA_TABLES][2][CBPPAT_VLC_SIZE]
static int rv34_decode_inter_mb_header(RV34DecContext *r, int8_t *intra_types)
Decode inter macroblock header and return CBP in case of success, -1 otherwise.
main external API structure.
static const uint8_t part_sizes_w[RV34_MB_TYPES]
macroblock partition width in 8x8 blocks
RV34VLC * cur_vlcs
VLC set used for current frame decoding.
int height
picture size. must be a multiple of 16
static const uint8_t rv34_inter_cbppat[NUM_INTER_TABLES][CBPPAT_VLC_SIZE]
int16_t(*[2] motion_val)[2]
motion vector table
SliceInfo si
current slice information
void(* pred16x16[4+3+2])(uint8_t *src, ptrdiff_t stride)
P-frame macroblock, 8x8 motion compensation partitions.
static unsigned int get_bits1(GetBitContext *s)
static void rv34_decoder_free(RV34DecContext *r)
VLC cbp[2][4]
VLCs used for coded block patterns decoding.
static av_cold void rv34_init_tables(void)
Initialize all tables.
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
av_cold int ff_rv34_decode_init(AVCodecContext *avctx)
Initialize decoder.
DSPContext dsp
pointers for accelerated dsp functions
int ff_rv34_decode_frame(AVCodecContext *avctx, void *data, int *got_picture_ptr, AVPacket *avpkt)
#define MB_TYPE_INTRA16x16
static const uint8_t rv34_table_inter_thirdpat[NUM_INTER_TABLES][2][OTHERBLK_VLC_SIZE]
void ff_rv40dsp_init(RV34DSPContext *c, DSPContext *dsp)
static int rv34_decode_inter_macroblock(RV34DecContext *r, int8_t *intra_types)
int intra_types_stride
block types array stride
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
miscellaneous RV30/40 tables
DCTELEM(* block)[64]
points to one of the following blocks
static void rv34_pred_mv_rv3(RV34DecContext *r, int block_type, int dir)
motion vector prediction - RV3 version
static int check_slice_end(RV34DecContext *r, MpegEncContext *s)
int is16
current block has additional 16x16 specific features or not
int8_t * intra_types
block types
static const uint8_t rv34_table_intra_cbp[NUM_INTRA_TABLES][8][CBP_VLC_SIZE]
P-frame macroblock, one motion frame.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int8_t * qscale_table
QP table.
int b8_stride
2*mb_width+1 used for some 8x8 block arrays to allow simple addressing
static int rv34_decode_cbp(GetBitContext *gb, RV34VLC *vlc, int table)
Decode coded block pattern.
Picture * next_picture_ptr
pointer to the next picture (for bidir pred)
av_cold int ff_rv34_decode_end(AVCodecContext *avctx)
struct AVCodecContext * avctx
static const uint8_t rv34_cbp_code[16]
values used to reconstruct coded block pattern
int(* decode_mb_info)(struct RV34DecContext *r)
#define VERT_LEFT_PRED_RV40_NODOWN
discard all non reference
#define OTHERBLK_VLC_SIZE
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
static const uint8_t avail_indexes[4]
availability index for subblocks
uint8_t * tmp_b_block_uv[4]
common internal api header.
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...
B-frame macroblock, backward prediction.
#define AVERROR_INVALIDDATA
static const uint8_t rv34_mb_bits_sizes[6]
bits needed to code the slice offset for the given size
int ff_rv34_decode_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
Picture * last_picture_ptr
pointer to the previous picture.
VLC third_pattern[2]
VLCs used for decoding coefficients in the last subblock.
static const int num_mvs[RV34_MB_TYPES]
number of motion vectors in each macroblock type
int ff_rv34_get_start_offset(GetBitContext *gb, int mb_size)
Decode starting slice position.
static const uint8_t modulo_three_table[108]
precalculated results of division by three and modulo three for values 0-107
void ff_MPV_common_end(MpegEncContext *s)
void ff_print_debug_info(MpegEncContext *s, AVFrame *pict)
Print debugging info for the given picture.
struct AVCodecInternal * internal
Private context used for internal data.
int resync_mb_y
y position of last resync marker
int block_type
current block type
VLC_TYPE(* table)[2]
code, bits
int linesize
line size, in bytes, may be different from width
const uint8_t * luma_dc_quant_i
luma subblock DC quantizer for intraframes
static const uint8_t rv34_count_ones[16]
number of ones in nibble minus one
static void decode_coeff(DCTELEM *dst, int coef, int esc, GetBitContext *gb, VLC *vlc, int q)
Get one coefficient value from the bistream and store it.
int * slice_offset
slice offsets in the frame in bytes
int8_t * intra_types_hist
old block types, used for prediction
int flags
AVCodecContext.flags (HQ, MV4, ...)
rv34_inv_transform_func rv34_inv_transform
int type
slice type (intra, inter)
h264_chroma_mc_func avg_chroma_pixels_tab[3]
av_cold void ff_rv30dsp_init(RV34DSPContext *c, DSPContext *dsp)
void ff_thread_report_progress(AVFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
static RV34VLC intra_vlcs[NUM_INTRA_TABLES]
int rv30
indicates which RV variasnt is currently decoded
int uvlinesize
line size, for chroma in bytes, may be different from width
This structure stores compressed data.
h264_chroma_mc_func put_chroma_pixels_tab[3]
static void decode_subblock1(DCTELEM *dst, int code, GetBitContext *gb, VLC *vlc, int q)
Decode a single coefficient.
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
int chroma_vlc
which VLC set will be used for decoding of chroma blocks
void ff_MPV_decode_defaults(MpegEncContext *s)
Set the given MpegEncContext to defaults for decoding.
static const uint8_t rv34_intra_coeff[NUM_INTRA_TABLES][COEFF_VLC_SIZE]
uint8_t * cbp_chroma
CBP values for chroma subblocks.