79 0, 1818, 3622, 4144, 4698, 5234, 5804, 5868, 5900, 5932,
80 5996, 6252, 6316, 6348, 6380, 7674, 8944, 10274, 11668, 12250,
81 14060, 15846, 16372, 16962, 17512, 18148, 18180, 18212, 18244, 18308,
82 18564, 18628, 18660, 18692, 20036, 21314, 22648, 23968, 24614, 26384,
83 28190, 28736, 29366, 29938, 30608, 30640, 30672, 30704, 30768, 31024,
84 31088, 31120, 31184, 32570, 33898, 35236, 36644, 37286, 39020, 40802,
85 41368, 42052, 42692, 43348, 43380, 43412, 43444, 43476, 43604, 43668,
86 43700, 43732, 45100, 46430, 47778, 49160, 49802, 51550, 53340, 53972,
87 54648, 55348, 55994, 56122, 56154, 56186, 56218, 56346, 56410, 56442,
88 56474, 57878, 59290, 60636, 62036, 62682, 64460, 64524, 64588, 64716,
89 64844, 66076, 67466, 67978, 68542, 69064, 69648, 70296, 72010, 72074,
90 72138, 72202, 72330, 73572, 74936, 75454, 76030, 76566, 77176, 77822,
91 79582, 79646, 79678, 79742, 79870, 81180, 82536, 83064, 83672, 84242,
92 84934, 85576, 87384, 87448, 87480, 87544, 87672, 88982, 90340, 90902,
93 91598, 92182, 92846, 93488, 95246, 95278, 95310, 95374, 95502, 96878,
94 98266, 98848, 99542, 100234, 100884, 101524, 103320, 103352, 103384, 103416,
95 103480, 104874, 106222, 106910, 107584, 108258, 108902, 109544, 111366, 111398,
96 111430, 111462, 111494, 112878, 114320, 114988, 115660, 116310, 116950, 117592
113 int counts[17] = {0}, codes[17];
116 int maxbits = 0, realsize = 0;
118 for(i = 0; i <
size; i++){
120 bits2[realsize] = bits[i];
121 syms[realsize] = insyms ? insyms[i] : i;
123 maxbits =
FFMAX(maxbits, bits[i]);
129 for(i = 0; i < 16; i++)
130 codes[i+1] = (codes[i] + counts[i]) << 1;
131 for(i = 0; i < realsize; i++)
132 cw[i] = codes[bits2[i]]++;
150 for(j = 0; j < 2; j++){
154 for(k = 0; k < 4; k++){
158 for(j = 0; j < 4; j++){
166 for(j = 0; j < 4; j++){
169 for(j = 0; j < 2; j++){
190 int pattern, code, cbp=0;
192 static const int cbp_masks[3] = {0x100000, 0x010000, 0x110000};
193 static const int shifts[4] = { 0, 2, 8, 10 };
194 const int *curshift =
shifts;
198 pattern = code & 0xF;
203 for(mask = 8;
mask; mask >>= 1, curshift++){
208 for(i = 0; i < 4; i++){
213 cbp |= cbp_masks[2] << i;
228 coef = 22 + ((1 << coef) |
get_bits(gb, coef));
234 *dst = (coef*q + 8) >> 4;
247 decode_coeff(dst+1*4+0, (flags >> 4) & 3, 2, gb, vlc, q);
248 decode_coeff(dst+0*4+1, (flags >> 2) & 3, 2, gb, vlc, q);
250 decode_coeff(dst+0*4+1, (flags >> 4) & 3, 2, gb, vlc, q);
251 decode_coeff(dst+1*4+0, (flags >> 2) & 3, 2, gb, vlc, q);
253 decode_coeff( dst+1*4+1, (flags >> 0) & 3, 2, gb, vlc, q);
266 int q_dc,
int q_ac1,
int q_ac2)
270 decode_coeff(dst+0*4+0, (flags >> 6) , 3, gb, vlc, q_dc);
271 decode_coeff(dst+0*4+1, (flags >> 4) & 3, 2, gb, vlc, q_ac1);
272 decode_coeff(dst+1*4+0, (flags >> 2) & 3, 2, gb, vlc, q_ac1);
273 decode_coeff(dst+1*4+1, (flags >> 0) & 3, 2, gb, vlc, q_ac2);
289 int code, pattern, has_ac = 1;
293 pattern = code & 0x7;
318 return has_ac | pattern;
333 for(i = 0; i < 5; i++)
344 if(mod == 2 && quant < 19) quant += 10;
345 else if(mod && quant < 26) quant += 5;
428 for(i = 0; i < 16; i++)
450 static const uint8_t part_sizes_w[
RV34_MB_TYPES] = { 2, 2, 2, 1, 2, 2, 2, 2, 2, 1, 2, 2 };
453 static const uint8_t part_sizes_h[
RV34_MB_TYPES] = { 2, 2, 2, 1, 2, 2, 2, 2, 1, 2, 2, 2 };
469 int A[2] = {0},
B[2],
C[2];
475 mv_pos += (subblock_no & 1) + (subblock_no >> 1)*s->
b8_stride;
491 if(avail[-4] && (avail[-1] || r->
rv30)){
504 mx += r->
dmv[dmv_no][0];
505 my += r->
dmv[dmv_no][1];
514 #define GET_PTS_DIFF(a, b) (((a) - (b) + 8192) & 0x1FFF)
523 return (val * mul + 0x2000) >> 14;
530 int A_avail,
int B_avail,
int C_avail,
533 if(A_avail + B_avail + C_avail != 3){
534 *mx = A[0] + B[0] + C[0];
535 *my = A[1] + B[1] + C[1];
536 if(A_avail + B_avail + C_avail == 2){
554 int A[2] = { 0 },
B[2] = { 0 },
C[2] = { 0 };
555 int has_A = 0, has_B = 0, has_C = 0;
563 A[0] = cur_pic->
motion_val[dir][mv_pos - 1][0];
564 A[1] = cur_pic->
motion_val[dir][mv_pos - 1][1];
584 mx += r->
dmv[dir][0];
585 my += r->
dmv[dir][1];
587 for(j = 0; j < 2; j++){
588 for(i = 0; i < 2; i++){
605 int A[2] = {0},
B[2],
C[2];
622 if(avail[-4] && (avail[-1])){
637 for(j = 0; j < 2; j++){
638 for(i = 0; i < 2; i++){
639 for(k = 0; k < 2; k++){
665 const int xoff,
const int yoff,
int mv_off,
667 const int thirdpel,
int weighted,
673 int dxy, mx, my, umx, umy, lx, ly, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
679 int chroma_mx, chroma_my;
686 umx = (chroma_mx + (3 << 24)) / 3 - (1 << 24);
687 umy = (chroma_my + (3 << 24)) / 3 - (1 << 24);
700 uvmx = (cx & 3) << 1;
701 uvmy = (cy & 3) << 1;
703 if(uvmx == 6 && uvmy == 6)
709 int mb_row = s->
mb_y + ((yoff + my + 5 + 8 *
height) >> 4);
718 src_x = s->
mb_x * 16 + xoff + mx;
719 src_y = s->
mb_y * 16 + yoff + my;
720 uvsrc_x = s->
mb_x * 8 + (xoff >> 1) + umx;
721 uvsrc_y = s->
mb_y * 8 + (yoff >> 1) + umy;
722 srcY += src_y * s->
linesize + src_x;
726 (
unsigned)(src_x - !!lx*2) > s->
h_edge_pos - !!lx*2 - (width <<3) - 4 ||
727 (unsigned)(src_y - !!ly*2) > s->
v_edge_pos - !!ly*2 - (height<<3) - 4) {
731 (width << 3) + 6, (height << 3) + 6,
732 src_x - 2, src_y - 2,
757 qpel_mc[!is16x16][dxy](
Y, srcY, s->
linesize);
763 (width << 2) + 1, (height << 2) + 1,
771 (width << 2) + 1, (height << 2) + 1,
781 const int xoff,
const int yoff,
int mv_off,
782 const int width,
const int height,
int dir)
784 rv34_mc(r, block_type, xoff, yoff, mv_off, width, height, dir, r->
rv30, 0,
815 rv34_mc(r, block_type, 0, 0, 0, 2, 2, 0, r->
rv30, weighted,
819 rv34_mc(r, block_type, 0, 0, 0, 2, 2, 1, r->
rv30, 0,
823 rv34_mc(r, block_type, 0, 0, 0, 2, 2, 1, r->
rv30, 1,
835 for(j = 0; j < 2; j++)
836 for(i = 0; i < 2; i++){
851 static const int num_mvs[
RV34_MB_TYPES] = { 0, 0, 1, 4, 1, 1, 0, 0, 2, 2, 2, 1 };
865 memset(r->
dmv, 0,
sizeof(r->
dmv));
866 for(i = 0; i < num_mvs[block_type]; i++){
892 for(j = 0; j < 2; j++)
893 for(i = 0; i < 2; i++)
894 for(k = 0; k < 2; k++)
895 for(l = 0; l < 2; l++)
910 r->
dmv[1][0] = r->
dmv[0][0];
911 r->
dmv[1][1] = r->
dmv[0][1];
968 uint8_t *prev = dst - stride + 4;
987 topleft = dst[-stride + 3] * 0x01010101
u;
1011 int fc,
int sc,
int q_dc,
int q_ac)
1014 int16_t *ptr = s->
block[0];
1016 fc, sc, q_dc, q_ac, q_ac);
1033 int16_t *ptr = s->
block[0];
1034 int i, j, itype, has_ac;
1036 memset(block16, 0, 16 *
sizeof(*block16));
1044 itype = ittrans16[intra_types[0]];
1048 for(j = 0; j < 4; j++){
1049 for(i = 0; i < 4; i++, cbp >>= 1){
1050 int dc = block16[i + j*4];
1067 itype = ittrans16[intra_types[0]];
1074 for(j = 1; j < 3; j++){
1077 for(i = 0; i < 4; i++, cbp >>= 1){
1079 if(!(cbp & 1))
continue;
1080 pdst = dst + (i&1)*4 + (i&2)*2*s->
uvlinesize;
1092 int avail[6*8] = {0};
1094 int idx, q_ac, q_dc;
1100 avail[1] = avail[2] = 1;
1102 avail[3] = avail[4] = 1;
1106 avail[8] = avail[16] = 1;
1108 avail[24] = avail[32] = 1;
1111 for(j = 0; j < 4; j++){
1113 for(i = 0; i < 4; i++, cbp >>= 1, dst += 4, idx++){
1116 if(!(cbp & 1))
continue;
1130 for(k = 0; k < 2; k++){
1134 for(j = 0; j < 2; j++){
1136 for(i = 0; i < 2; i++, cbp >>= 1, acache++){
1141 if(!(cbp&1))
continue;
1155 d = motion_val[0][0] - motion_val[-step][0];
1158 d = motion_val[0][1] - motion_val[-step][1];
1167 int hmvmask = 0, vmvmask = 0, i, j;
1170 for(j = 0; j < 16; j += 8){
1171 for(i = 0; i < 2; i++){
1173 vmvmask |= 0x11 << (j + i*2);
1175 hmvmask |= 0x03 << (j + i*2);
1184 vmvmask |= (vmvmask & 0x4444) >> 1;
1185 hmvmask |= (hmvmask & 0x0F00) >> 4;
1191 return hmvmask | vmvmask;
1199 int16_t *ptr = s->
block[0];
1202 int q_dc, q_ac, has_ac;
1240 memset(block16, 0, 16 *
sizeof(*block16));
1250 for(j = 0; j < 4; j++){
1251 for(i = 0; i < 4; i++, cbp >>= 1){
1252 int dc = block16[i + j*4];
1273 for(j = 0; j < 4; j++){
1274 for(i = 0; i < 4; i++, cbp >>= 1){
1275 if(!(cbp & 1))
continue;
1287 for(j = 1; j < 3; j++){
1289 for(i = 0; i < 4; i++, cbp >>= 1){
1291 if(!(cbp & 1))
continue;
1292 pdst = dst + (i&1)*4 + (i&2)*2*s->
uvlinesize;
1352 if(bits <= 0 || (bits < 8 && !
show_bits(&s->
gb, bits)))
1408 int mb_pos, slice_type;
1506 #if CONFIG_RV30_DECODER
1510 #if CONFIG_RV40_DECODER
1520 if(!intra_vlcs[0].cbppattern[0].
bits)
1555 if (dst == src || !
s1->context_initialized)
1571 memset(&r->
si, 0,
sizeof(r->
si));
1591 int got_picture = 0,
ret;
1628 void *
data,
int *got_picture_ptr,
1632 int buf_size = avpkt->
size;
1643 if (buf_size == 0) {
1650 *got_picture_ptr = 1;
1656 slice_count = (*buf++) + 1;
1657 slices_hdr = buf + 4;
1658 buf += 8 * slice_count;
1659 buf_size -= 1 + 8 * slice_count;
1677 "reference data.\n");
1686 if (si.
start == 0) {
1726 for (i = 0; i < 2; i++)
1729 for (i = 0; i < 4; i++)
1762 }
else if (HAVE_THREADS &&
1765 "multithreading mode (start MB is %d).\n", si.
start);
1769 for(i = 0; i < slice_count; i++){
1772 if(i+1 == slice_count)
1773 size = buf_size -
offset;
1777 if(offset < 0 || offset > buf_size){
1785 if(i+1 < slice_count){
1793 if(i+2 < slice_count)
1796 size = buf_size -
offset;
1817 *got_picture_ptr =
ret;
1818 }
else if (HAVE_THREADS &&
qpel_mc_func put_pixels_tab[4][16]
P-frame macroblock with DCs in a separate 4x4 block, one motion vector.
void ff_rv40dsp_init(RV34DSPContext *c)
#define MB_TYPE_INTRA16x16
int vlc_set
VLCs used for this slice.
const char const char void * val
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)
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
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)
ptrdiff_t const GLvoid * data
void(* loop_filter)(struct RV34DecContext *r, int row)
uint32_t avail_cache[3 *4]
8x8 block available flags (for MV prediction)
uint8_t * edge_emu_buffer
temporary buffer for if MVs point to out-of-frame data
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
#define AV_LOG_WARNING
Something somehow does not look correct.
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
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.
Bidirectionally predicted B-frame macroblock, two motion vectors.
static int rv34_decode_block(int16_t *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_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)
int ff_init_vlc_sparse(VLC *vlc_arg, 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 const uint8_t rv34_chroma_quant[2][32]
quantizer values used for AC and DC coefficients in chroma blocks
Bidirectionally predicted B-frame macroblock, no motion vectors.
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
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...
void(* qpel_mc_func)(uint8_t *dst, const uint8_t *src, ptrdiff_t stride)
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)
void ff_thread_await_progress(ThreadFrame *f, int n, int field)
Wait for earlier decoding threads to finish reference pictures.
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
static void decode_subblock3(int16_t *dst, int code, GetBitContext *gb, VLC *vlc, int q_dc, int q_ac1, int q_ac2)
#define FF_QSCALE_TYPE_MPEG1
enum AVDiscard skip_frame
Skip decoding for selected frames.
void(* emulated_edge_mc)(uint8_t *dst, const uint8_t *src, ptrdiff_t dst_linesize, ptrdiff_t src_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...
uint8_t * tmp_b_block_base
int mb_num_left
number of MBs left in this video packet (for partitioned Slices only)
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.
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)
int ff_mpv_common_frame_size_change(MpegEncContext *s)
static av_cold int end(AVCodecContext *avctx)
Multithreading support functions.
#define HOR_UP_PRED_RV40_NODOWN
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
#define MB_TYPE_SEPARATE_DC
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
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]
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
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]
av_cold void ff_mpv_idct_init(MpegEncContext *s)
int mb_height
number of MBs horizontally & vertically
static void fill_rectangle(SDL_Surface *screen, int x, int y, int w, int h, int color, int update)
static const uint16_t rv34_qscale_tab[32]
This table is used for dequantizing.
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 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...
static void decode_subblock1(int16_t *dst, int code, GetBitContext *gb, VLC *vlc, int q)
Decode a single coefficient.
int slice_count
slice count
int quant
quantizer used for this slice
static int get_bits_left(GetBitContext *gb)
static const int table_offs[]
qpel_mc_func avg_pixels_tab[4][16]
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
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.
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
static const struct endianess table[]
av_cold void ff_rv30dsp_init(RV34DSPContext *c)
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
static AVRational update_sar(int old_w, int old_h, AVRational sar, int new_w, int new_h)
static int rv34_decoder_realloc(RV34DecContext *r)
av_cold void ff_h264_pred_init(H264PredContext *h, int codec_id, const int bit_depth, int chroma_format_idc)
Set the intra prediction function pointers.
int low_delay
no reordering needed / has no b-frames
static const uint8_t offset[127][2]
void ff_mpv_common_end(MpegEncContext *s)
Libavcodec external API header.
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_set_deblock_coef(RV34DecContext *r)
common internal API header
useful rectangle filling function
static void ZERO8x2(void *dst, int stride)
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
static const uint16_t fc[]
int ff_mpv_export_qp_table(MpegEncContext *s, AVFrame *f, Picture *p, int qp_type)
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)
int16_t(*[2] motion_val)[2]
Picture * current_picture_ptr
pointer to the current picture
void ff_mpeg_er_frame_start(MpegEncContext *s)
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.
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
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.
#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]
#define INIT_VLC_USE_NEW_STATIC
int ff_mpeg_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
void ff_mpv_decode_defaults(MpegEncContext *s)
Set the given MpegEncContext to defaults for decoding.
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)
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)
#define AV_LOG_INFO
Standard information.
static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
essential slice information
ptrdiff_t linesize
line size, in bytes, may be different from width
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]
SliceInfo si
current slice information
void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
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)
BYTE int const BYTE int int int height
#define FF_THREAD_FRAME
Decode more than one frame at once.
static void rv34_decoder_free(RV34DecContext *r)
VLC cbp[2][4]
VLCs used for coded block patterns decoding.
rational number numerator/denominator
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.
ptrdiff_t uvlinesize
line size, for chroma in bytes, may be different from width
int ff_rv34_decode_frame(AVCodecContext *avctx, void *data, int *got_picture_ptr, AVPacket *avpkt)
static const uint8_t rv34_table_inter_thirdpat[NUM_INTER_TABLES][2][OTHERBLK_VLC_SIZE]
int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
generic function called after decoding the header and before a frame is decoded.
static int rv34_decode_inter_macroblock(RV34DecContext *r, int8_t *intra_types)
int allocate_progress
Whether to allocate progress for frame threading.
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
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.
int b8_stride
2*mb_width+1 used for some 8x8 block arrays to allow simple addressing
void(* h264_chroma_mc_func)(uint8_t *dst, uint8_t *src, int srcStride, int h, int x, int y)
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
GLint GLenum GLboolean GLsizei stride
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 ...
void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
B-frame macroblock, backward prediction.
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)
static const uint8_t shifts[2][12]
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
av_cold int ff_mpv_common_init(MpegEncContext *s)
init common structure for both encoder and decoder.
void ff_mpv_frame_end(MpegEncContext *s)
struct AVCodecInternal * internal
Private context used for internal data.
int resync_mb_y
y position of last resync marker
int16_t(* block)[64]
points to one of the following blocks
int block_type
current block type
VLC_TYPE(* table)[2]
code, bits
static const double coeff[2][5]
const uint8_t * luma_dc_quant_i
luma subblock DC quantizer for intraframes
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> dc
static const uint8_t rv34_count_ones[16]
number of ones in nibble minus one
int * slice_offset
slice offsets in the frame in bytes
int8_t * intra_types_hist
old block types, used for prediction
rv34_inv_transform_func rv34_inv_transform
uint32_t * mb_type
types and macros are defined in mpegutils.h
#define LOCAL_ALIGNED_16(t, v,...)
static void decode_subblock(int16_t *dst, int code, const int is_block2, GetBitContext *gb, VLC *vlc, int q)
Decode 2x2 subblock of coefficients.
int type
slice type (intra, inter)
h264_chroma_mc_func avg_chroma_pixels_tab[3]
static void decode_coeff(int16_t *dst, int coef, int esc, GetBitContext *gb, VLC *vlc, int q)
Get one coefficient value from the bitstream and store it.
static RV34VLC intra_vlcs[NUM_INTRA_TABLES]
int rv30
indicates which RV variasnt is currently decoded
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
This structure stores compressed data.
h264_chroma_mc_func put_chroma_pixels_tab[3]
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
static const uint8_t rv34_intra_coeff[NUM_INTRA_TABLES][COEFF_VLC_SIZE]
uint8_t * cbp_chroma
CBP values for chroma subblocks.