00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00027 #include "libavutil/imgutils.h"
00028 #include "libavutil/internal.h"
00029
00030 #include "avcodec.h"
00031 #include "dsputil.h"
00032 #include "mpegvideo.h"
00033 #include "golomb.h"
00034 #include "internal.h"
00035 #include "mathops.h"
00036 #include "rectangle.h"
00037 #include "thread.h"
00038
00039 #include "rv34vlc.h"
00040 #include "rv34data.h"
00041 #include "rv34.h"
00042
00043
00044
00045 static inline void ZERO8x2(void* dst, int stride)
00046 {
00047 fill_rectangle(dst, 1, 2, stride, 0, 4);
00048 fill_rectangle(((uint8_t*)(dst))+4, 1, 2, stride, 0, 4);
00049 }
00050
00052 static const int rv34_mb_type_to_lavc[12] = {
00053 MB_TYPE_INTRA,
00054 MB_TYPE_INTRA16x16 | MB_TYPE_SEPARATE_DC,
00055 MB_TYPE_16x16 | MB_TYPE_L0,
00056 MB_TYPE_8x8 | MB_TYPE_L0,
00057 MB_TYPE_16x16 | MB_TYPE_L0,
00058 MB_TYPE_16x16 | MB_TYPE_L1,
00059 MB_TYPE_SKIP,
00060 MB_TYPE_DIRECT2 | MB_TYPE_16x16,
00061 MB_TYPE_16x8 | MB_TYPE_L0,
00062 MB_TYPE_8x16 | MB_TYPE_L0,
00063 MB_TYPE_16x16 | MB_TYPE_L0L1,
00064 MB_TYPE_16x16 | MB_TYPE_L0 | MB_TYPE_SEPARATE_DC
00065 };
00066
00067
00068 static RV34VLC intra_vlcs[NUM_INTRA_TABLES], inter_vlcs[NUM_INTER_TABLES];
00069
00070 static int rv34_decode_mv(RV34DecContext *r, int block_type);
00071
00077 static const int table_offs[] = {
00078 0, 1818, 3622, 4144, 4698, 5234, 5804, 5868, 5900, 5932,
00079 5996, 6252, 6316, 6348, 6380, 7674, 8944, 10274, 11668, 12250,
00080 14060, 15846, 16372, 16962, 17512, 18148, 18180, 18212, 18244, 18308,
00081 18564, 18628, 18660, 18692, 20036, 21314, 22648, 23968, 24614, 26384,
00082 28190, 28736, 29366, 29938, 30608, 30640, 30672, 30704, 30768, 31024,
00083 31088, 31120, 31184, 32570, 33898, 35236, 36644, 37286, 39020, 40802,
00084 41368, 42052, 42692, 43348, 43380, 43412, 43444, 43476, 43604, 43668,
00085 43700, 43732, 45100, 46430, 47778, 49160, 49802, 51550, 53340, 53972,
00086 54648, 55348, 55994, 56122, 56154, 56186, 56218, 56346, 56410, 56442,
00087 56474, 57878, 59290, 60636, 62036, 62682, 64460, 64524, 64588, 64716,
00088 64844, 66076, 67466, 67978, 68542, 69064, 69648, 70296, 72010, 72074,
00089 72138, 72202, 72330, 73572, 74936, 75454, 76030, 76566, 77176, 77822,
00090 79582, 79646, 79678, 79742, 79870, 81180, 82536, 83064, 83672, 84242,
00091 84934, 85576, 87384, 87448, 87480, 87544, 87672, 88982, 90340, 90902,
00092 91598, 92182, 92846, 93488, 95246, 95278, 95310, 95374, 95502, 96878,
00093 98266, 98848, 99542, 100234, 100884, 101524, 103320, 103352, 103384, 103416,
00094 103480, 104874, 106222, 106910, 107584, 108258, 108902, 109544, 111366, 111398,
00095 111430, 111462, 111494, 112878, 114320, 114988, 115660, 116310, 116950, 117592
00096 };
00097
00098 static VLC_TYPE table_data[117592][2];
00099
00108 static void rv34_gen_vlc(const uint8_t *bits, int size, VLC *vlc, const uint8_t *insyms,
00109 const int num)
00110 {
00111 int i;
00112 int counts[17] = {0}, codes[17];
00113 uint16_t cw[MAX_VLC_SIZE], syms[MAX_VLC_SIZE];
00114 uint8_t bits2[MAX_VLC_SIZE];
00115 int maxbits = 0, realsize = 0;
00116
00117 for(i = 0; i < size; i++){
00118 if(bits[i]){
00119 bits2[realsize] = bits[i];
00120 syms[realsize] = insyms ? insyms[i] : i;
00121 realsize++;
00122 maxbits = FFMAX(maxbits, bits[i]);
00123 counts[bits[i]]++;
00124 }
00125 }
00126
00127 codes[0] = 0;
00128 for(i = 0; i < 16; i++)
00129 codes[i+1] = (codes[i] + counts[i]) << 1;
00130 for(i = 0; i < realsize; i++)
00131 cw[i] = codes[bits2[i]]++;
00132
00133 vlc->table = &table_data[table_offs[num]];
00134 vlc->table_allocated = table_offs[num + 1] - table_offs[num];
00135 ff_init_vlc_sparse(vlc, FFMIN(maxbits, 9), realsize,
00136 bits2, 1, 1,
00137 cw, 2, 2,
00138 syms, 2, 2, INIT_VLC_USE_NEW_STATIC);
00139 }
00140
00144 static av_cold void rv34_init_tables(void)
00145 {
00146 int i, j, k;
00147
00148 for(i = 0; i < NUM_INTRA_TABLES; i++){
00149 for(j = 0; j < 2; j++){
00150 rv34_gen_vlc(rv34_table_intra_cbppat [i][j], CBPPAT_VLC_SIZE, &intra_vlcs[i].cbppattern[j], NULL, 19*i + 0 + j);
00151 rv34_gen_vlc(rv34_table_intra_secondpat[i][j], OTHERBLK_VLC_SIZE, &intra_vlcs[i].second_pattern[j], NULL, 19*i + 2 + j);
00152 rv34_gen_vlc(rv34_table_intra_thirdpat [i][j], OTHERBLK_VLC_SIZE, &intra_vlcs[i].third_pattern[j], NULL, 19*i + 4 + j);
00153 for(k = 0; k < 4; k++){
00154 rv34_gen_vlc(rv34_table_intra_cbp[i][j+k*2], CBP_VLC_SIZE, &intra_vlcs[i].cbp[j][k], rv34_cbp_code, 19*i + 6 + j*4 + k);
00155 }
00156 }
00157 for(j = 0; j < 4; j++){
00158 rv34_gen_vlc(rv34_table_intra_firstpat[i][j], FIRSTBLK_VLC_SIZE, &intra_vlcs[i].first_pattern[j], NULL, 19*i + 14 + j);
00159 }
00160 rv34_gen_vlc(rv34_intra_coeff[i], COEFF_VLC_SIZE, &intra_vlcs[i].coefficient, NULL, 19*i + 18);
00161 }
00162
00163 for(i = 0; i < NUM_INTER_TABLES; i++){
00164 rv34_gen_vlc(rv34_inter_cbppat[i], CBPPAT_VLC_SIZE, &inter_vlcs[i].cbppattern[0], NULL, i*12 + 95);
00165 for(j = 0; j < 4; j++){
00166 rv34_gen_vlc(rv34_inter_cbp[i][j], CBP_VLC_SIZE, &inter_vlcs[i].cbp[0][j], rv34_cbp_code, i*12 + 96 + j);
00167 }
00168 for(j = 0; j < 2; j++){
00169 rv34_gen_vlc(rv34_table_inter_firstpat [i][j], FIRSTBLK_VLC_SIZE, &inter_vlcs[i].first_pattern[j], NULL, i*12 + 100 + j);
00170 rv34_gen_vlc(rv34_table_inter_secondpat[i][j], OTHERBLK_VLC_SIZE, &inter_vlcs[i].second_pattern[j], NULL, i*12 + 102 + j);
00171 rv34_gen_vlc(rv34_table_inter_thirdpat [i][j], OTHERBLK_VLC_SIZE, &inter_vlcs[i].third_pattern[j], NULL, i*12 + 104 + j);
00172 }
00173 rv34_gen_vlc(rv34_inter_coeff[i], COEFF_VLC_SIZE, &inter_vlcs[i].coefficient, NULL, i*12 + 106);
00174 }
00175 }
00176
00178
00187 static int rv34_decode_cbp(GetBitContext *gb, RV34VLC *vlc, int table)
00188 {
00189 int pattern, code, cbp=0;
00190 int ones;
00191 static const int cbp_masks[3] = {0x100000, 0x010000, 0x110000};
00192 static const int shifts[4] = { 0, 2, 8, 10 };
00193 const int *curshift = shifts;
00194 int i, t, mask;
00195
00196 code = get_vlc2(gb, vlc->cbppattern[table].table, 9, 2);
00197 pattern = code & 0xF;
00198 code >>= 4;
00199
00200 ones = rv34_count_ones[pattern];
00201
00202 for(mask = 8; mask; mask >>= 1, curshift++){
00203 if(pattern & mask)
00204 cbp |= get_vlc2(gb, vlc->cbp[table][ones].table, vlc->cbp[table][ones].bits, 1) << curshift[0];
00205 }
00206
00207 for(i = 0; i < 4; i++){
00208 t = (modulo_three_table[code] >> (6 - 2*i)) & 3;
00209 if(t == 1)
00210 cbp |= cbp_masks[get_bits1(gb)] << i;
00211 if(t == 2)
00212 cbp |= cbp_masks[2] << i;
00213 }
00214 return cbp;
00215 }
00216
00220 static inline void decode_coeff(DCTELEM *dst, int coef, int esc, GetBitContext *gb, VLC* vlc, int q)
00221 {
00222 if(coef){
00223 if(coef == esc){
00224 coef = get_vlc2(gb, vlc->table, 9, 2);
00225 if(coef > 23){
00226 coef -= 23;
00227 coef = 22 + ((1 << coef) | get_bits(gb, coef));
00228 }
00229 coef += esc;
00230 }
00231 if(get_bits1(gb))
00232 coef = -coef;
00233 *dst = (coef*q + 8) >> 4;
00234 }
00235 }
00236
00240 static inline void decode_subblock(DCTELEM *dst, int code, const int is_block2, GetBitContext *gb, VLC *vlc, int q)
00241 {
00242 int flags = modulo_three_table[code];
00243
00244 decode_coeff( dst+0*4+0, (flags >> 6) , 3, gb, vlc, q);
00245 if(is_block2){
00246 decode_coeff(dst+1*4+0, (flags >> 4) & 3, 2, gb, vlc, q);
00247 decode_coeff(dst+0*4+1, (flags >> 2) & 3, 2, gb, vlc, q);
00248 }else{
00249 decode_coeff(dst+0*4+1, (flags >> 4) & 3, 2, gb, vlc, q);
00250 decode_coeff(dst+1*4+0, (flags >> 2) & 3, 2, gb, vlc, q);
00251 }
00252 decode_coeff( dst+1*4+1, (flags >> 0) & 3, 2, gb, vlc, q);
00253 }
00254
00258 static inline void decode_subblock1(DCTELEM *dst, int code, GetBitContext *gb, VLC *vlc, int q)
00259 {
00260 int coeff = modulo_three_table[code] >> 6;
00261 decode_coeff(dst, coeff, 3, gb, vlc, q);
00262 }
00263
00264 static inline void decode_subblock3(DCTELEM *dst, int code, GetBitContext *gb, VLC *vlc,
00265 int q_dc, int q_ac1, int q_ac2)
00266 {
00267 int flags = modulo_three_table[code];
00268
00269 decode_coeff(dst+0*4+0, (flags >> 6) , 3, gb, vlc, q_dc);
00270 decode_coeff(dst+0*4+1, (flags >> 4) & 3, 2, gb, vlc, q_ac1);
00271 decode_coeff(dst+1*4+0, (flags >> 2) & 3, 2, gb, vlc, q_ac1);
00272 decode_coeff(dst+1*4+1, (flags >> 0) & 3, 2, gb, vlc, q_ac2);
00273 }
00274
00286 static int rv34_decode_block(DCTELEM *dst, GetBitContext *gb, RV34VLC *rvlc, int fc, int sc, int q_dc, int q_ac1, int q_ac2)
00287 {
00288 int code, pattern, has_ac = 1;
00289
00290 code = get_vlc2(gb, rvlc->first_pattern[fc].table, 9, 2);
00291
00292 pattern = code & 0x7;
00293
00294 code >>= 3;
00295
00296 if (modulo_three_table[code] & 0x3F) {
00297 decode_subblock3(dst, code, gb, &rvlc->coefficient, q_dc, q_ac1, q_ac2);
00298 } else {
00299 decode_subblock1(dst, code, gb, &rvlc->coefficient, q_dc);
00300 if (!pattern)
00301 return 0;
00302 has_ac = 0;
00303 }
00304
00305 if(pattern & 4){
00306 code = get_vlc2(gb, rvlc->second_pattern[sc].table, 9, 2);
00307 decode_subblock(dst + 4*0+2, code, 0, gb, &rvlc->coefficient, q_ac2);
00308 }
00309 if(pattern & 2){
00310 code = get_vlc2(gb, rvlc->second_pattern[sc].table, 9, 2);
00311 decode_subblock(dst + 4*2+0, code, 1, gb, &rvlc->coefficient, q_ac2);
00312 }
00313 if(pattern & 1){
00314 code = get_vlc2(gb, rvlc->third_pattern[sc].table, 9, 2);
00315 decode_subblock(dst + 4*2+2, code, 0, gb, &rvlc->coefficient, q_ac2);
00316 }
00317 return has_ac | pattern;
00318 }
00319
00329 int ff_rv34_get_start_offset(GetBitContext *gb, int mb_size)
00330 {
00331 int i;
00332 for(i = 0; i < 5; i++)
00333 if(rv34_mb_max_sizes[i] >= mb_size - 1)
00334 break;
00335 return rv34_mb_bits_sizes[i];
00336 }
00337
00341 static inline RV34VLC* choose_vlc_set(int quant, int mod, int type)
00342 {
00343 if(mod == 2 && quant < 19) quant += 10;
00344 else if(mod && quant < 26) quant += 5;
00345 return type ? &inter_vlcs[rv34_quant_to_vlc_set[1][av_clip(quant, 0, 30)]]
00346 : &intra_vlcs[rv34_quant_to_vlc_set[0][av_clip(quant, 0, 30)]];
00347 }
00348
00352 static int rv34_decode_intra_mb_header(RV34DecContext *r, int8_t *intra_types)
00353 {
00354 MpegEncContext *s = &r->s;
00355 GetBitContext *gb = &s->gb;
00356 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
00357 int t;
00358
00359 r->is16 = get_bits1(gb);
00360 if(r->is16){
00361 s->current_picture_ptr->f.mb_type[mb_pos] = MB_TYPE_INTRA16x16;
00362 r->block_type = RV34_MB_TYPE_INTRA16x16;
00363 t = get_bits(gb, 2);
00364 fill_rectangle(intra_types, 4, 4, r->intra_types_stride, t, sizeof(intra_types[0]));
00365 r->luma_vlc = 2;
00366 }else{
00367 if(!r->rv30){
00368 if(!get_bits1(gb))
00369 av_log(s->avctx, AV_LOG_ERROR, "Need DQUANT\n");
00370 }
00371 s->current_picture_ptr->f.mb_type[mb_pos] = MB_TYPE_INTRA;
00372 r->block_type = RV34_MB_TYPE_INTRA;
00373 if(r->decode_intra_types(r, gb, intra_types) < 0)
00374 return -1;
00375 r->luma_vlc = 1;
00376 }
00377
00378 r->chroma_vlc = 0;
00379 r->cur_vlcs = choose_vlc_set(r->si.quant, r->si.vlc_set, 0);
00380
00381 return rv34_decode_cbp(gb, r->cur_vlcs, r->is16);
00382 }
00383
00387 static int rv34_decode_inter_mb_header(RV34DecContext *r, int8_t *intra_types)
00388 {
00389 MpegEncContext *s = &r->s;
00390 GetBitContext *gb = &s->gb;
00391 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
00392 int i, t;
00393
00394 r->block_type = r->decode_mb_info(r);
00395 if(r->block_type == -1)
00396 return -1;
00397 s->current_picture_ptr->f.mb_type[mb_pos] = rv34_mb_type_to_lavc[r->block_type];
00398 r->mb_type[mb_pos] = r->block_type;
00399 if(r->block_type == RV34_MB_SKIP){
00400 if(s->pict_type == AV_PICTURE_TYPE_P)
00401 r->mb_type[mb_pos] = RV34_MB_P_16x16;
00402 if(s->pict_type == AV_PICTURE_TYPE_B)
00403 r->mb_type[mb_pos] = RV34_MB_B_DIRECT;
00404 }
00405 r->is16 = !!IS_INTRA16x16(s->current_picture_ptr->f.mb_type[mb_pos]);
00406 rv34_decode_mv(r, r->block_type);
00407 if(r->block_type == RV34_MB_SKIP){
00408 fill_rectangle(intra_types, 4, 4, r->intra_types_stride, 0, sizeof(intra_types[0]));
00409 return 0;
00410 }
00411 r->chroma_vlc = 1;
00412 r->luma_vlc = 0;
00413
00414 if(IS_INTRA(s->current_picture_ptr->f.mb_type[mb_pos])){
00415 if(r->is16){
00416 t = get_bits(gb, 2);
00417 fill_rectangle(intra_types, 4, 4, r->intra_types_stride, t, sizeof(intra_types[0]));
00418 r->luma_vlc = 2;
00419 }else{
00420 if(r->decode_intra_types(r, gb, intra_types) < 0)
00421 return -1;
00422 r->luma_vlc = 1;
00423 }
00424 r->chroma_vlc = 0;
00425 r->cur_vlcs = choose_vlc_set(r->si.quant, r->si.vlc_set, 0);
00426 }else{
00427 for(i = 0; i < 16; i++)
00428 intra_types[(i & 3) + (i>>2) * r->intra_types_stride] = 0;
00429 r->cur_vlcs = choose_vlc_set(r->si.quant, r->si.vlc_set, 1);
00430 if(r->mb_type[mb_pos] == RV34_MB_P_MIX16x16){
00431 r->is16 = 1;
00432 r->chroma_vlc = 1;
00433 r->luma_vlc = 2;
00434 r->cur_vlcs = choose_vlc_set(r->si.quant, r->si.vlc_set, 0);
00435 }
00436 }
00437
00438 return rv34_decode_cbp(gb, r->cur_vlcs, r->is16);
00439 }
00440
00442
00449 static const uint8_t part_sizes_w[RV34_MB_TYPES] = { 2, 2, 2, 1, 2, 2, 2, 2, 2, 1, 2, 2 };
00450
00452 static const uint8_t part_sizes_h[RV34_MB_TYPES] = { 2, 2, 2, 1, 2, 2, 2, 2, 1, 2, 2, 2 };
00453
00455 static const uint8_t avail_indexes[4] = { 6, 7, 10, 11 };
00456
00464 static void rv34_pred_mv(RV34DecContext *r, int block_type, int subblock_no, int dmv_no)
00465 {
00466 MpegEncContext *s = &r->s;
00467 int mv_pos = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride;
00468 int A[2] = {0}, B[2], C[2];
00469 int i, j;
00470 int mx, my;
00471 int* avail = r->avail_cache + avail_indexes[subblock_no];
00472 int c_off = part_sizes_w[block_type];
00473
00474 mv_pos += (subblock_no & 1) + (subblock_no >> 1)*s->b8_stride;
00475 if(subblock_no == 3)
00476 c_off = -1;
00477
00478 if(avail[-1]){
00479 A[0] = s->current_picture_ptr->f.motion_val[0][mv_pos-1][0];
00480 A[1] = s->current_picture_ptr->f.motion_val[0][mv_pos-1][1];
00481 }
00482 if(avail[-4]){
00483 B[0] = s->current_picture_ptr->f.motion_val[0][mv_pos-s->b8_stride][0];
00484 B[1] = s->current_picture_ptr->f.motion_val[0][mv_pos-s->b8_stride][1];
00485 }else{
00486 B[0] = A[0];
00487 B[1] = A[1];
00488 }
00489 if(!avail[c_off-4]){
00490 if(avail[-4] && (avail[-1] || r->rv30)){
00491 C[0] = s->current_picture_ptr->f.motion_val[0][mv_pos-s->b8_stride-1][0];
00492 C[1] = s->current_picture_ptr->f.motion_val[0][mv_pos-s->b8_stride-1][1];
00493 }else{
00494 C[0] = A[0];
00495 C[1] = A[1];
00496 }
00497 }else{
00498 C[0] = s->current_picture_ptr->f.motion_val[0][mv_pos-s->b8_stride+c_off][0];
00499 C[1] = s->current_picture_ptr->f.motion_val[0][mv_pos-s->b8_stride+c_off][1];
00500 }
00501 mx = mid_pred(A[0], B[0], C[0]);
00502 my = mid_pred(A[1], B[1], C[1]);
00503 mx += r->dmv[dmv_no][0];
00504 my += r->dmv[dmv_no][1];
00505 for(j = 0; j < part_sizes_h[block_type]; j++){
00506 for(i = 0; i < part_sizes_w[block_type]; i++){
00507 s->current_picture_ptr->f.motion_val[0][mv_pos + i + j*s->b8_stride][0] = mx;
00508 s->current_picture_ptr->f.motion_val[0][mv_pos + i + j*s->b8_stride][1] = my;
00509 }
00510 }
00511 }
00512
00513 #define GET_PTS_DIFF(a, b) ((a - b + 8192) & 0x1FFF)
00514
00518 static int calc_add_mv(RV34DecContext *r, int dir, int val)
00519 {
00520 int mul = dir ? -r->mv_weight2 : r->mv_weight1;
00521
00522 return (val * mul + 0x2000) >> 14;
00523 }
00524
00528 static inline void rv34_pred_b_vector(int A[2], int B[2], int C[2],
00529 int A_avail, int B_avail, int C_avail,
00530 int *mx, int *my)
00531 {
00532 if(A_avail + B_avail + C_avail != 3){
00533 *mx = A[0] + B[0] + C[0];
00534 *my = A[1] + B[1] + C[1];
00535 if(A_avail + B_avail + C_avail == 2){
00536 *mx /= 2;
00537 *my /= 2;
00538 }
00539 }else{
00540 *mx = mid_pred(A[0], B[0], C[0]);
00541 *my = mid_pred(A[1], B[1], C[1]);
00542 }
00543 }
00544
00548 static void rv34_pred_mv_b(RV34DecContext *r, int block_type, int dir)
00549 {
00550 MpegEncContext *s = &r->s;
00551 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
00552 int mv_pos = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride;
00553 int A[2] = { 0 }, B[2] = { 0 }, C[2] = { 0 };
00554 int has_A = 0, has_B = 0, has_C = 0;
00555 int mx, my;
00556 int i, j;
00557 Picture *cur_pic = s->current_picture_ptr;
00558 const int mask = dir ? MB_TYPE_L1 : MB_TYPE_L0;
00559 int type = cur_pic->f.mb_type[mb_pos];
00560
00561 if((r->avail_cache[6-1] & type) & mask){
00562 A[0] = cur_pic->f.motion_val[dir][mv_pos - 1][0];
00563 A[1] = cur_pic->f.motion_val[dir][mv_pos - 1][1];
00564 has_A = 1;
00565 }
00566 if((r->avail_cache[6-4] & type) & mask){
00567 B[0] = cur_pic->f.motion_val[dir][mv_pos - s->b8_stride][0];
00568 B[1] = cur_pic->f.motion_val[dir][mv_pos - s->b8_stride][1];
00569 has_B = 1;
00570 }
00571 if(r->avail_cache[6-4] && (r->avail_cache[6-2] & type) & mask){
00572 C[0] = cur_pic->f.motion_val[dir][mv_pos - s->b8_stride + 2][0];
00573 C[1] = cur_pic->f.motion_val[dir][mv_pos - s->b8_stride + 2][1];
00574 has_C = 1;
00575 }else if((s->mb_x+1) == s->mb_width && (r->avail_cache[6-5] & type) & mask){
00576 C[0] = cur_pic->f.motion_val[dir][mv_pos - s->b8_stride - 1][0];
00577 C[1] = cur_pic->f.motion_val[dir][mv_pos - s->b8_stride - 1][1];
00578 has_C = 1;
00579 }
00580
00581 rv34_pred_b_vector(A, B, C, has_A, has_B, has_C, &mx, &my);
00582
00583 mx += r->dmv[dir][0];
00584 my += r->dmv[dir][1];
00585
00586 for(j = 0; j < 2; j++){
00587 for(i = 0; i < 2; i++){
00588 cur_pic->f.motion_val[dir][mv_pos + i + j*s->b8_stride][0] = mx;
00589 cur_pic->f.motion_val[dir][mv_pos + i + j*s->b8_stride][1] = my;
00590 }
00591 }
00592 if(block_type == RV34_MB_B_BACKWARD || block_type == RV34_MB_B_FORWARD){
00593 ZERO8x2(cur_pic->f.motion_val[!dir][mv_pos], s->b8_stride);
00594 }
00595 }
00596
00600 static void rv34_pred_mv_rv3(RV34DecContext *r, int block_type, int dir)
00601 {
00602 MpegEncContext *s = &r->s;
00603 int mv_pos = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride;
00604 int A[2] = {0}, B[2], C[2];
00605 int i, j, k;
00606 int mx, my;
00607 int* avail = r->avail_cache + avail_indexes[0];
00608
00609 if(avail[-1]){
00610 A[0] = s->current_picture_ptr->f.motion_val[0][mv_pos - 1][0];
00611 A[1] = s->current_picture_ptr->f.motion_val[0][mv_pos - 1][1];
00612 }
00613 if(avail[-4]){
00614 B[0] = s->current_picture_ptr->f.motion_val[0][mv_pos - s->b8_stride][0];
00615 B[1] = s->current_picture_ptr->f.motion_val[0][mv_pos - s->b8_stride][1];
00616 }else{
00617 B[0] = A[0];
00618 B[1] = A[1];
00619 }
00620 if(!avail[-4 + 2]){
00621 if(avail[-4] && (avail[-1])){
00622 C[0] = s->current_picture_ptr->f.motion_val[0][mv_pos - s->b8_stride - 1][0];
00623 C[1] = s->current_picture_ptr->f.motion_val[0][mv_pos - s->b8_stride - 1][1];
00624 }else{
00625 C[0] = A[0];
00626 C[1] = A[1];
00627 }
00628 }else{
00629 C[0] = s->current_picture_ptr->f.motion_val[0][mv_pos - s->b8_stride + 2][0];
00630 C[1] = s->current_picture_ptr->f.motion_val[0][mv_pos - s->b8_stride + 2][1];
00631 }
00632 mx = mid_pred(A[0], B[0], C[0]);
00633 my = mid_pred(A[1], B[1], C[1]);
00634 mx += r->dmv[0][0];
00635 my += r->dmv[0][1];
00636 for(j = 0; j < 2; j++){
00637 for(i = 0; i < 2; i++){
00638 for(k = 0; k < 2; k++){
00639 s->current_picture_ptr->f.motion_val[k][mv_pos + i + j*s->b8_stride][0] = mx;
00640 s->current_picture_ptr->f.motion_val[k][mv_pos + i + j*s->b8_stride][1] = my;
00641 }
00642 }
00643 }
00644 }
00645
00646 static const int chroma_coeffs[3] = { 0, 3, 5 };
00647
00663 static inline void rv34_mc(RV34DecContext *r, const int block_type,
00664 const int xoff, const int yoff, int mv_off,
00665 const int width, const int height, int dir,
00666 const int thirdpel, int weighted,
00667 qpel_mc_func (*qpel_mc)[16],
00668 h264_chroma_mc_func (*chroma_mc))
00669 {
00670 MpegEncContext *s = &r->s;
00671 uint8_t *Y, *U, *V, *srcY, *srcU, *srcV;
00672 int dxy, mx, my, umx, umy, lx, ly, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
00673 int mv_pos = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride + mv_off;
00674 int is16x16 = 1;
00675
00676 if(thirdpel){
00677 int chroma_mx, chroma_my;
00678 mx = (s->current_picture_ptr->f.motion_val[dir][mv_pos][0] + (3 << 24)) / 3 - (1 << 24);
00679 my = (s->current_picture_ptr->f.motion_val[dir][mv_pos][1] + (3 << 24)) / 3 - (1 << 24);
00680 lx = (s->current_picture_ptr->f.motion_val[dir][mv_pos][0] + (3 << 24)) % 3;
00681 ly = (s->current_picture_ptr->f.motion_val[dir][mv_pos][1] + (3 << 24)) % 3;
00682 chroma_mx = s->current_picture_ptr->f.motion_val[dir][mv_pos][0] / 2;
00683 chroma_my = s->current_picture_ptr->f.motion_val[dir][mv_pos][1] / 2;
00684 umx = (chroma_mx + (3 << 24)) / 3 - (1 << 24);
00685 umy = (chroma_my + (3 << 24)) / 3 - (1 << 24);
00686 uvmx = chroma_coeffs[(chroma_mx + (3 << 24)) % 3];
00687 uvmy = chroma_coeffs[(chroma_my + (3 << 24)) % 3];
00688 }else{
00689 int cx, cy;
00690 mx = s->current_picture_ptr->f.motion_val[dir][mv_pos][0] >> 2;
00691 my = s->current_picture_ptr->f.motion_val[dir][mv_pos][1] >> 2;
00692 lx = s->current_picture_ptr->f.motion_val[dir][mv_pos][0] & 3;
00693 ly = s->current_picture_ptr->f.motion_val[dir][mv_pos][1] & 3;
00694 cx = s->current_picture_ptr->f.motion_val[dir][mv_pos][0] / 2;
00695 cy = s->current_picture_ptr->f.motion_val[dir][mv_pos][1] / 2;
00696 umx = cx >> 2;
00697 umy = cy >> 2;
00698 uvmx = (cx & 3) << 1;
00699 uvmy = (cy & 3) << 1;
00700
00701 if(uvmx == 6 && uvmy == 6)
00702 uvmx = uvmy = 4;
00703 }
00704
00705 if (HAVE_THREADS && (s->avctx->active_thread_type & FF_THREAD_FRAME)) {
00706
00707 int mb_row = s->mb_y + ((yoff + my + 5 + 8 * height) >> 4);
00708 AVFrame *f = dir ? &s->next_picture_ptr->f : &s->last_picture_ptr->f;
00709 ff_thread_await_progress(f, mb_row, 0);
00710 }
00711
00712 dxy = ly*4 + lx;
00713 srcY = dir ? s->next_picture_ptr->f.data[0] : s->last_picture_ptr->f.data[0];
00714 srcU = dir ? s->next_picture_ptr->f.data[1] : s->last_picture_ptr->f.data[1];
00715 srcV = dir ? s->next_picture_ptr->f.data[2] : s->last_picture_ptr->f.data[2];
00716 src_x = s->mb_x * 16 + xoff + mx;
00717 src_y = s->mb_y * 16 + yoff + my;
00718 uvsrc_x = s->mb_x * 8 + (xoff >> 1) + umx;
00719 uvsrc_y = s->mb_y * 8 + (yoff >> 1) + umy;
00720 srcY += src_y * s->linesize + src_x;
00721 srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
00722 srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
00723 if(s->h_edge_pos - (width << 3) < 6 || s->v_edge_pos - (height << 3) < 6 ||
00724 (unsigned)(src_x - !!lx*2) > s->h_edge_pos - !!lx*2 - (width <<3) - 4 ||
00725 (unsigned)(src_y - !!ly*2) > s->v_edge_pos - !!ly*2 - (height<<3) - 4) {
00726 uint8_t *uvbuf = s->edge_emu_buffer + 22 * s->linesize;
00727
00728 srcY -= 2 + 2*s->linesize;
00729 s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, (width<<3)+6, (height<<3)+6,
00730 src_x - 2, src_y - 2, s->h_edge_pos, s->v_edge_pos);
00731 srcY = s->edge_emu_buffer + 2 + 2*s->linesize;
00732 s->dsp.emulated_edge_mc(uvbuf , srcU, s->uvlinesize, (width<<2)+1, (height<<2)+1,
00733 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
00734 s->dsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, (width<<2)+1, (height<<2)+1,
00735 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1);
00736 srcU = uvbuf;
00737 srcV = uvbuf + 16;
00738 }
00739 if(!weighted){
00740 Y = s->dest[0] + xoff + yoff *s->linesize;
00741 U = s->dest[1] + (xoff>>1) + (yoff>>1)*s->uvlinesize;
00742 V = s->dest[2] + (xoff>>1) + (yoff>>1)*s->uvlinesize;
00743 }else{
00744 Y = r->tmp_b_block_y [dir] + xoff + yoff *s->linesize;
00745 U = r->tmp_b_block_uv[dir*2] + (xoff>>1) + (yoff>>1)*s->uvlinesize;
00746 V = r->tmp_b_block_uv[dir*2+1] + (xoff>>1) + (yoff>>1)*s->uvlinesize;
00747 }
00748
00749 if(block_type == RV34_MB_P_16x8){
00750 qpel_mc[1][dxy](Y, srcY, s->linesize);
00751 Y += 8;
00752 srcY += 8;
00753 }else if(block_type == RV34_MB_P_8x16){
00754 qpel_mc[1][dxy](Y, srcY, s->linesize);
00755 Y += 8 * s->linesize;
00756 srcY += 8 * s->linesize;
00757 }
00758 is16x16 = (block_type != RV34_MB_P_8x8) && (block_type != RV34_MB_P_16x8) && (block_type != RV34_MB_P_8x16);
00759 qpel_mc[!is16x16][dxy](Y, srcY, s->linesize);
00760 chroma_mc[2-width] (U, srcU, s->uvlinesize, height*4, uvmx, uvmy);
00761 chroma_mc[2-width] (V, srcV, s->uvlinesize, height*4, uvmx, uvmy);
00762 }
00763
00764 static void rv34_mc_1mv(RV34DecContext *r, const int block_type,
00765 const int xoff, const int yoff, int mv_off,
00766 const int width, const int height, int dir)
00767 {
00768 rv34_mc(r, block_type, xoff, yoff, mv_off, width, height, dir, r->rv30, 0,
00769 r->rdsp.put_pixels_tab,
00770 r->rdsp.put_chroma_pixels_tab);
00771 }
00772
00773 static void rv4_weight(RV34DecContext *r)
00774 {
00775 r->rdsp.rv40_weight_pixels_tab[r->scaled_weight][0](r->s.dest[0],
00776 r->tmp_b_block_y[0],
00777 r->tmp_b_block_y[1],
00778 r->weight1,
00779 r->weight2,
00780 r->s.linesize);
00781 r->rdsp.rv40_weight_pixels_tab[r->scaled_weight][1](r->s.dest[1],
00782 r->tmp_b_block_uv[0],
00783 r->tmp_b_block_uv[2],
00784 r->weight1,
00785 r->weight2,
00786 r->s.uvlinesize);
00787 r->rdsp.rv40_weight_pixels_tab[r->scaled_weight][1](r->s.dest[2],
00788 r->tmp_b_block_uv[1],
00789 r->tmp_b_block_uv[3],
00790 r->weight1,
00791 r->weight2,
00792 r->s.uvlinesize);
00793 }
00794
00795 static void rv34_mc_2mv(RV34DecContext *r, const int block_type)
00796 {
00797 int weighted = !r->rv30 && block_type != RV34_MB_B_BIDIR && r->weight1 != 8192;
00798
00799 rv34_mc(r, block_type, 0, 0, 0, 2, 2, 0, r->rv30, weighted,
00800 r->rdsp.put_pixels_tab,
00801 r->rdsp.put_chroma_pixels_tab);
00802 if(!weighted){
00803 rv34_mc(r, block_type, 0, 0, 0, 2, 2, 1, r->rv30, 0,
00804 r->rdsp.avg_pixels_tab,
00805 r->rdsp.avg_chroma_pixels_tab);
00806 }else{
00807 rv34_mc(r, block_type, 0, 0, 0, 2, 2, 1, r->rv30, 1,
00808 r->rdsp.put_pixels_tab,
00809 r->rdsp.put_chroma_pixels_tab);
00810 rv4_weight(r);
00811 }
00812 }
00813
00814 static void rv34_mc_2mv_skip(RV34DecContext *r)
00815 {
00816 int i, j;
00817 int weighted = !r->rv30 && r->weight1 != 8192;
00818
00819 for(j = 0; j < 2; j++)
00820 for(i = 0; i < 2; i++){
00821 rv34_mc(r, RV34_MB_P_8x8, i*8, j*8, i+j*r->s.b8_stride, 1, 1, 0, r->rv30,
00822 weighted,
00823 r->rdsp.put_pixels_tab,
00824 r->rdsp.put_chroma_pixels_tab);
00825 rv34_mc(r, RV34_MB_P_8x8, i*8, j*8, i+j*r->s.b8_stride, 1, 1, 1, r->rv30,
00826 weighted,
00827 weighted ? r->rdsp.put_pixels_tab : r->rdsp.avg_pixels_tab,
00828 weighted ? r->rdsp.put_chroma_pixels_tab : r->rdsp.avg_chroma_pixels_tab);
00829 }
00830 if(weighted)
00831 rv4_weight(r);
00832 }
00833
00835 static const int num_mvs[RV34_MB_TYPES] = { 0, 0, 1, 4, 1, 1, 0, 0, 2, 2, 2, 1 };
00836
00841 static int rv34_decode_mv(RV34DecContext *r, int block_type)
00842 {
00843 MpegEncContext *s = &r->s;
00844 GetBitContext *gb = &s->gb;
00845 int i, j, k, l;
00846 int mv_pos = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride;
00847 int next_bt;
00848
00849 memset(r->dmv, 0, sizeof(r->dmv));
00850 for(i = 0; i < num_mvs[block_type]; i++){
00851 r->dmv[i][0] = svq3_get_se_golomb(gb);
00852 r->dmv[i][1] = svq3_get_se_golomb(gb);
00853 }
00854 switch(block_type){
00855 case RV34_MB_TYPE_INTRA:
00856 case RV34_MB_TYPE_INTRA16x16:
00857 ZERO8x2(s->current_picture_ptr->f.motion_val[0][s->mb_x * 2 + s->mb_y * 2 * s->b8_stride], s->b8_stride);
00858 return 0;
00859 case RV34_MB_SKIP:
00860 if(s->pict_type == AV_PICTURE_TYPE_P){
00861 ZERO8x2(s->current_picture_ptr->f.motion_val[0][s->mb_x * 2 + s->mb_y * 2 * s->b8_stride], s->b8_stride);
00862 rv34_mc_1mv (r, block_type, 0, 0, 0, 2, 2, 0);
00863 break;
00864 }
00865 case RV34_MB_B_DIRECT:
00866
00867
00868 if (HAVE_THREADS && (s->avctx->active_thread_type & FF_THREAD_FRAME))
00869 ff_thread_await_progress(&s->next_picture_ptr->f, FFMAX(0, s->mb_y-1), 0);
00870
00871 next_bt = s->next_picture_ptr->f.mb_type[s->mb_x + s->mb_y * s->mb_stride];
00872 if(IS_INTRA(next_bt) || IS_SKIP(next_bt)){
00873 ZERO8x2(s->current_picture_ptr->f.motion_val[0][s->mb_x * 2 + s->mb_y * 2 * s->b8_stride], s->b8_stride);
00874 ZERO8x2(s->current_picture_ptr->f.motion_val[1][s->mb_x * 2 + s->mb_y * 2 * s->b8_stride], s->b8_stride);
00875 }else
00876 for(j = 0; j < 2; j++)
00877 for(i = 0; i < 2; i++)
00878 for(k = 0; k < 2; k++)
00879 for(l = 0; l < 2; l++)
00880 s->current_picture_ptr->f.motion_val[l][mv_pos + i + j*s->b8_stride][k] = calc_add_mv(r, l, s->next_picture_ptr->f.motion_val[0][mv_pos + i + j*s->b8_stride][k]);
00881 if(!(IS_16X8(next_bt) || IS_8X16(next_bt) || IS_8X8(next_bt)))
00882 rv34_mc_2mv(r, block_type);
00883 else
00884 rv34_mc_2mv_skip(r);
00885 ZERO8x2(s->current_picture_ptr->f.motion_val[0][s->mb_x * 2 + s->mb_y * 2 * s->b8_stride], s->b8_stride);
00886 break;
00887 case RV34_MB_P_16x16:
00888 case RV34_MB_P_MIX16x16:
00889 rv34_pred_mv(r, block_type, 0, 0);
00890 rv34_mc_1mv (r, block_type, 0, 0, 0, 2, 2, 0);
00891 break;
00892 case RV34_MB_B_FORWARD:
00893 case RV34_MB_B_BACKWARD:
00894 r->dmv[1][0] = r->dmv[0][0];
00895 r->dmv[1][1] = r->dmv[0][1];
00896 if(r->rv30)
00897 rv34_pred_mv_rv3(r, block_type, block_type == RV34_MB_B_BACKWARD);
00898 else
00899 rv34_pred_mv_b (r, block_type, block_type == RV34_MB_B_BACKWARD);
00900 rv34_mc_1mv (r, block_type, 0, 0, 0, 2, 2, block_type == RV34_MB_B_BACKWARD);
00901 break;
00902 case RV34_MB_P_16x8:
00903 case RV34_MB_P_8x16:
00904 rv34_pred_mv(r, block_type, 0, 0);
00905 rv34_pred_mv(r, block_type, 1 + (block_type == RV34_MB_P_16x8), 1);
00906 if(block_type == RV34_MB_P_16x8){
00907 rv34_mc_1mv(r, block_type, 0, 0, 0, 2, 1, 0);
00908 rv34_mc_1mv(r, block_type, 0, 8, s->b8_stride, 2, 1, 0);
00909 }
00910 if(block_type == RV34_MB_P_8x16){
00911 rv34_mc_1mv(r, block_type, 0, 0, 0, 1, 2, 0);
00912 rv34_mc_1mv(r, block_type, 8, 0, 1, 1, 2, 0);
00913 }
00914 break;
00915 case RV34_MB_B_BIDIR:
00916 rv34_pred_mv_b (r, block_type, 0);
00917 rv34_pred_mv_b (r, block_type, 1);
00918 rv34_mc_2mv (r, block_type);
00919 break;
00920 case RV34_MB_P_8x8:
00921 for(i=0;i< 4;i++){
00922 rv34_pred_mv(r, block_type, i, i);
00923 rv34_mc_1mv (r, block_type, (i&1)<<3, (i&2)<<2, (i&1)+(i>>1)*s->b8_stride, 1, 1, 0);
00924 }
00925 break;
00926 }
00927
00928 return 0;
00929 }
00931
00937 static const int ittrans[9] = {
00938 DC_PRED, VERT_PRED, HOR_PRED, DIAG_DOWN_RIGHT_PRED, DIAG_DOWN_LEFT_PRED,
00939 VERT_RIGHT_PRED, VERT_LEFT_PRED, HOR_UP_PRED, HOR_DOWN_PRED,
00940 };
00941
00943 static const int ittrans16[4] = {
00944 DC_PRED8x8, VERT_PRED8x8, HOR_PRED8x8, PLANE_PRED8x8,
00945 };
00946
00950 static void rv34_pred_4x4_block(RV34DecContext *r, uint8_t *dst, int stride, int itype, int up, int left, int down, int right)
00951 {
00952 uint8_t *prev = dst - stride + 4;
00953 uint32_t topleft;
00954
00955 if(!up && !left)
00956 itype = DC_128_PRED;
00957 else if(!up){
00958 if(itype == VERT_PRED) itype = HOR_PRED;
00959 if(itype == DC_PRED) itype = LEFT_DC_PRED;
00960 }else if(!left){
00961 if(itype == HOR_PRED) itype = VERT_PRED;
00962 if(itype == DC_PRED) itype = TOP_DC_PRED;
00963 if(itype == DIAG_DOWN_LEFT_PRED) itype = DIAG_DOWN_LEFT_PRED_RV40_NODOWN;
00964 }
00965 if(!down){
00966 if(itype == DIAG_DOWN_LEFT_PRED) itype = DIAG_DOWN_LEFT_PRED_RV40_NODOWN;
00967 if(itype == HOR_UP_PRED) itype = HOR_UP_PRED_RV40_NODOWN;
00968 if(itype == VERT_LEFT_PRED) itype = VERT_LEFT_PRED_RV40_NODOWN;
00969 }
00970 if(!right && up){
00971 topleft = dst[-stride + 3] * 0x01010101u;
00972 prev = (uint8_t*)&topleft;
00973 }
00974 r->h.pred4x4[itype](dst, prev, stride);
00975 }
00976
00977 static inline int adjust_pred16(int itype, int up, int left)
00978 {
00979 if(!up && !left)
00980 itype = DC_128_PRED8x8;
00981 else if(!up){
00982 if(itype == PLANE_PRED8x8)itype = HOR_PRED8x8;
00983 if(itype == VERT_PRED8x8) itype = HOR_PRED8x8;
00984 if(itype == DC_PRED8x8) itype = LEFT_DC_PRED8x8;
00985 }else if(!left){
00986 if(itype == PLANE_PRED8x8)itype = VERT_PRED8x8;
00987 if(itype == HOR_PRED8x8) itype = VERT_PRED8x8;
00988 if(itype == DC_PRED8x8) itype = TOP_DC_PRED8x8;
00989 }
00990 return itype;
00991 }
00992
00993 static inline void rv34_process_block(RV34DecContext *r,
00994 uint8_t *pdst, int stride,
00995 int fc, int sc, int q_dc, int q_ac)
00996 {
00997 MpegEncContext *s = &r->s;
00998 DCTELEM *ptr = s->block[0];
00999 int has_ac = rv34_decode_block(ptr, &s->gb, r->cur_vlcs,
01000 fc, sc, q_dc, q_ac, q_ac);
01001 if(has_ac){
01002 r->rdsp.rv34_idct_add(pdst, stride, ptr);
01003 }else{
01004 r->rdsp.rv34_idct_dc_add(pdst, stride, ptr[0]);
01005 ptr[0] = 0;
01006 }
01007 }
01008
01009 static void rv34_output_i16x16(RV34DecContext *r, int8_t *intra_types, int cbp)
01010 {
01011 LOCAL_ALIGNED_16(DCTELEM, block16, [16]);
01012 MpegEncContext *s = &r->s;
01013 GetBitContext *gb = &s->gb;
01014 int q_dc = rv34_qscale_tab[ r->luma_dc_quant_i[s->qscale] ],
01015 q_ac = rv34_qscale_tab[s->qscale];
01016 uint8_t *dst = s->dest[0];
01017 DCTELEM *ptr = s->block[0];
01018 int i, j, itype, has_ac;
01019
01020 memset(block16, 0, 16 * sizeof(*block16));
01021
01022 has_ac = rv34_decode_block(block16, gb, r->cur_vlcs, 3, 0, q_dc, q_dc, q_ac);
01023 if(has_ac)
01024 r->rdsp.rv34_inv_transform(block16);
01025 else
01026 r->rdsp.rv34_inv_transform_dc(block16);
01027
01028 itype = ittrans16[intra_types[0]];
01029 itype = adjust_pred16(itype, r->avail_cache[6-4], r->avail_cache[6-1]);
01030 r->h.pred16x16[itype](dst, s->linesize);
01031
01032 for(j = 0; j < 4; j++){
01033 for(i = 0; i < 4; i++, cbp >>= 1){
01034 int dc = block16[i + j*4];
01035
01036 if(cbp & 1){
01037 has_ac = rv34_decode_block(ptr, gb, r->cur_vlcs, r->luma_vlc, 0, q_ac, q_ac, q_ac);
01038 }else
01039 has_ac = 0;
01040
01041 if(has_ac){
01042 ptr[0] = dc;
01043 r->rdsp.rv34_idct_add(dst+4*i, s->linesize, ptr);
01044 }else
01045 r->rdsp.rv34_idct_dc_add(dst+4*i, s->linesize, dc);
01046 }
01047
01048 dst += 4*s->linesize;
01049 }
01050
01051 itype = ittrans16[intra_types[0]];
01052 if(itype == PLANE_PRED8x8) itype = DC_PRED8x8;
01053 itype = adjust_pred16(itype, r->avail_cache[6-4], r->avail_cache[6-1]);
01054
01055 q_dc = rv34_qscale_tab[rv34_chroma_quant[1][s->qscale]];
01056 q_ac = rv34_qscale_tab[rv34_chroma_quant[0][s->qscale]];
01057
01058 for(j = 1; j < 3; j++){
01059 dst = s->dest[j];
01060 r->h.pred8x8[itype](dst, s->uvlinesize);
01061 for(i = 0; i < 4; i++, cbp >>= 1){
01062 uint8_t *pdst;
01063 if(!(cbp & 1)) continue;
01064 pdst = dst + (i&1)*4 + (i&2)*2*s->uvlinesize;
01065
01066 rv34_process_block(r, pdst, s->uvlinesize,
01067 r->chroma_vlc, 1, q_dc, q_ac);
01068 }
01069 }
01070 }
01071
01072 static void rv34_output_intra(RV34DecContext *r, int8_t *intra_types, int cbp)
01073 {
01074 MpegEncContext *s = &r->s;
01075 uint8_t *dst = s->dest[0];
01076 int avail[6*8] = {0};
01077 int i, j, k;
01078 int idx, q_ac, q_dc;
01079
01080
01081 if(r->avail_cache[1])
01082 avail[0] = 1;
01083 if(r->avail_cache[2])
01084 avail[1] = avail[2] = 1;
01085 if(r->avail_cache[3])
01086 avail[3] = avail[4] = 1;
01087 if(r->avail_cache[4])
01088 avail[5] = 1;
01089 if(r->avail_cache[5])
01090 avail[8] = avail[16] = 1;
01091 if(r->avail_cache[9])
01092 avail[24] = avail[32] = 1;
01093
01094 q_ac = rv34_qscale_tab[s->qscale];
01095 for(j = 0; j < 4; j++){
01096 idx = 9 + j*8;
01097 for(i = 0; i < 4; i++, cbp >>= 1, dst += 4, idx++){
01098 rv34_pred_4x4_block(r, dst, s->linesize, ittrans[intra_types[i]], avail[idx-8], avail[idx-1], avail[idx+7], avail[idx-7]);
01099 avail[idx] = 1;
01100 if(!(cbp & 1)) continue;
01101
01102 rv34_process_block(r, dst, s->linesize,
01103 r->luma_vlc, 0, q_ac, q_ac);
01104 }
01105 dst += s->linesize * 4 - 4*4;
01106 intra_types += r->intra_types_stride;
01107 }
01108
01109 intra_types -= r->intra_types_stride * 4;
01110
01111 q_dc = rv34_qscale_tab[rv34_chroma_quant[1][s->qscale]];
01112 q_ac = rv34_qscale_tab[rv34_chroma_quant[0][s->qscale]];
01113
01114 for(k = 0; k < 2; k++){
01115 dst = s->dest[1+k];
01116 fill_rectangle(r->avail_cache + 6, 2, 2, 4, 0, 4);
01117
01118 for(j = 0; j < 2; j++){
01119 int* acache = r->avail_cache + 6 + j*4;
01120 for(i = 0; i < 2; i++, cbp >>= 1, acache++){
01121 int itype = ittrans[intra_types[i*2+j*2*r->intra_types_stride]];
01122 rv34_pred_4x4_block(r, dst+4*i, s->uvlinesize, itype, acache[-4], acache[-1], !i && !j, acache[-3]);
01123 acache[0] = 1;
01124
01125 if(!(cbp&1)) continue;
01126
01127 rv34_process_block(r, dst + 4*i, s->uvlinesize,
01128 r->chroma_vlc, 1, q_dc, q_ac);
01129 }
01130
01131 dst += 4*s->uvlinesize;
01132 }
01133 }
01134 }
01135
01136 static int is_mv_diff_gt_3(int16_t (*motion_val)[2], int step)
01137 {
01138 int d;
01139 d = motion_val[0][0] - motion_val[-step][0];
01140 if(d < -3 || d > 3)
01141 return 1;
01142 d = motion_val[0][1] - motion_val[-step][1];
01143 if(d < -3 || d > 3)
01144 return 1;
01145 return 0;
01146 }
01147
01148 static int rv34_set_deblock_coef(RV34DecContext *r)
01149 {
01150 MpegEncContext *s = &r->s;
01151 int hmvmask = 0, vmvmask = 0, i, j;
01152 int midx = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride;
01153 int16_t (*motion_val)[2] = &s->current_picture_ptr->f.motion_val[0][midx];
01154 for(j = 0; j < 16; j += 8){
01155 for(i = 0; i < 2; i++){
01156 if(is_mv_diff_gt_3(motion_val + i, 1))
01157 vmvmask |= 0x11 << (j + i*2);
01158 if((j || s->mb_y) && is_mv_diff_gt_3(motion_val + i, s->b8_stride))
01159 hmvmask |= 0x03 << (j + i*2);
01160 }
01161 motion_val += s->b8_stride;
01162 }
01163 if(s->first_slice_line)
01164 hmvmask &= ~0x000F;
01165 if(!s->mb_x)
01166 vmvmask &= ~0x1111;
01167 if(r->rv30){
01168 vmvmask |= (vmvmask & 0x4444) >> 1;
01169 hmvmask |= (hmvmask & 0x0F00) >> 4;
01170 if(s->mb_x)
01171 r->deblock_coefs[s->mb_x - 1 + s->mb_y*s->mb_stride] |= (vmvmask & 0x1111) << 3;
01172 if(!s->first_slice_line)
01173 r->deblock_coefs[s->mb_x + (s->mb_y - 1)*s->mb_stride] |= (hmvmask & 0xF) << 12;
01174 }
01175 return hmvmask | vmvmask;
01176 }
01177
01178 static int rv34_decode_inter_macroblock(RV34DecContext *r, int8_t *intra_types)
01179 {
01180 MpegEncContext *s = &r->s;
01181 GetBitContext *gb = &s->gb;
01182 uint8_t *dst = s->dest[0];
01183 DCTELEM *ptr = s->block[0];
01184 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
01185 int cbp, cbp2;
01186 int q_dc, q_ac, has_ac;
01187 int i, j;
01188 int dist;
01189
01190
01191 memset(r->avail_cache, 0, sizeof(r->avail_cache));
01192 fill_rectangle(r->avail_cache + 6, 2, 2, 4, 1, 4);
01193 dist = (s->mb_x - s->resync_mb_x) + (s->mb_y - s->resync_mb_y) * s->mb_width;
01194 if(s->mb_x && dist)
01195 r->avail_cache[5] =
01196 r->avail_cache[9] = s->current_picture_ptr->f.mb_type[mb_pos - 1];
01197 if(dist >= s->mb_width)
01198 r->avail_cache[2] =
01199 r->avail_cache[3] = s->current_picture_ptr->f.mb_type[mb_pos - s->mb_stride];
01200 if(((s->mb_x+1) < s->mb_width) && dist >= s->mb_width - 1)
01201 r->avail_cache[4] = s->current_picture_ptr->f.mb_type[mb_pos - s->mb_stride + 1];
01202 if(s->mb_x && dist > s->mb_width)
01203 r->avail_cache[1] = s->current_picture_ptr->f.mb_type[mb_pos - s->mb_stride - 1];
01204
01205 s->qscale = r->si.quant;
01206 cbp = cbp2 = rv34_decode_inter_mb_header(r, intra_types);
01207 r->cbp_luma [mb_pos] = cbp;
01208 r->cbp_chroma[mb_pos] = cbp >> 16;
01209 r->deblock_coefs[mb_pos] = rv34_set_deblock_coef(r) | r->cbp_luma[mb_pos];
01210 s->current_picture_ptr->f.qscale_table[mb_pos] = s->qscale;
01211
01212 if(cbp == -1)
01213 return -1;
01214
01215 if (IS_INTRA(s->current_picture_ptr->f.mb_type[mb_pos])){
01216 if(r->is16) rv34_output_i16x16(r, intra_types, cbp);
01217 else rv34_output_intra(r, intra_types, cbp);
01218 return 0;
01219 }
01220
01221 if(r->is16){
01222
01223 LOCAL_ALIGNED_16(DCTELEM, block16, [16]);
01224 memset(block16, 0, 16 * sizeof(*block16));
01225 q_dc = rv34_qscale_tab[ r->luma_dc_quant_p[s->qscale] ];
01226 q_ac = rv34_qscale_tab[s->qscale];
01227 if (rv34_decode_block(block16, gb, r->cur_vlcs, 3, 0, q_dc, q_dc, q_ac))
01228 r->rdsp.rv34_inv_transform(block16);
01229 else
01230 r->rdsp.rv34_inv_transform_dc(block16);
01231
01232 q_ac = rv34_qscale_tab[s->qscale];
01233
01234 for(j = 0; j < 4; j++){
01235 for(i = 0; i < 4; i++, cbp >>= 1){
01236 int dc = block16[i + j*4];
01237
01238 if(cbp & 1){
01239 has_ac = rv34_decode_block(ptr, gb, r->cur_vlcs, r->luma_vlc, 0, q_ac, q_ac, q_ac);
01240 }else
01241 has_ac = 0;
01242
01243 if(has_ac){
01244 ptr[0] = dc;
01245 r->rdsp.rv34_idct_add(dst+4*i, s->linesize, ptr);
01246 }else
01247 r->rdsp.rv34_idct_dc_add(dst+4*i, s->linesize, dc);
01248 }
01249
01250 dst += 4*s->linesize;
01251 }
01252
01253 r->cur_vlcs = choose_vlc_set(r->si.quant, r->si.vlc_set, 1);
01254 }else{
01255 q_ac = rv34_qscale_tab[s->qscale];
01256
01257 for(j = 0; j < 4; j++){
01258 for(i = 0; i < 4; i++, cbp >>= 1){
01259 if(!(cbp & 1)) continue;
01260
01261 rv34_process_block(r, dst + 4*i, s->linesize,
01262 r->luma_vlc, 0, q_ac, q_ac);
01263 }
01264 dst += 4*s->linesize;
01265 }
01266 }
01267
01268 q_dc = rv34_qscale_tab[rv34_chroma_quant[1][s->qscale]];
01269 q_ac = rv34_qscale_tab[rv34_chroma_quant[0][s->qscale]];
01270
01271 for(j = 1; j < 3; j++){
01272 dst = s->dest[j];
01273 for(i = 0; i < 4; i++, cbp >>= 1){
01274 uint8_t *pdst;
01275 if(!(cbp & 1)) continue;
01276 pdst = dst + (i&1)*4 + (i&2)*2*s->uvlinesize;
01277
01278 rv34_process_block(r, pdst, s->uvlinesize,
01279 r->chroma_vlc, 1, q_dc, q_ac);
01280 }
01281 }
01282
01283 return 0;
01284 }
01285
01286 static int rv34_decode_intra_macroblock(RV34DecContext *r, int8_t *intra_types)
01287 {
01288 MpegEncContext *s = &r->s;
01289 int cbp, dist;
01290 int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
01291
01292
01293 memset(r->avail_cache, 0, sizeof(r->avail_cache));
01294 fill_rectangle(r->avail_cache + 6, 2, 2, 4, 1, 4);
01295 dist = (s->mb_x - s->resync_mb_x) + (s->mb_y - s->resync_mb_y) * s->mb_width;
01296 if(s->mb_x && dist)
01297 r->avail_cache[5] =
01298 r->avail_cache[9] = s->current_picture_ptr->f.mb_type[mb_pos - 1];
01299 if(dist >= s->mb_width)
01300 r->avail_cache[2] =
01301 r->avail_cache[3] = s->current_picture_ptr->f.mb_type[mb_pos - s->mb_stride];
01302 if(((s->mb_x+1) < s->mb_width) && dist >= s->mb_width - 1)
01303 r->avail_cache[4] = s->current_picture_ptr->f.mb_type[mb_pos - s->mb_stride + 1];
01304 if(s->mb_x && dist > s->mb_width)
01305 r->avail_cache[1] = s->current_picture_ptr->f.mb_type[mb_pos - s->mb_stride - 1];
01306
01307 s->qscale = r->si.quant;
01308 cbp = rv34_decode_intra_mb_header(r, intra_types);
01309 r->cbp_luma [mb_pos] = cbp;
01310 r->cbp_chroma[mb_pos] = cbp >> 16;
01311 r->deblock_coefs[mb_pos] = 0xFFFF;
01312 s->current_picture_ptr->f.qscale_table[mb_pos] = s->qscale;
01313
01314 if(cbp == -1)
01315 return -1;
01316
01317 if(r->is16){
01318 rv34_output_i16x16(r, intra_types, cbp);
01319 return 0;
01320 }
01321
01322 rv34_output_intra(r, intra_types, cbp);
01323 return 0;
01324 }
01325
01326 static int check_slice_end(RV34DecContext *r, MpegEncContext *s)
01327 {
01328 int bits;
01329 if(s->mb_y >= s->mb_height)
01330 return 1;
01331 if(!s->mb_num_left)
01332 return 1;
01333 if(r->s.mb_skip_run > 1)
01334 return 0;
01335 bits = get_bits_left(&s->gb);
01336 if(bits <= 0 || (bits < 8 && !show_bits(&s->gb, bits)))
01337 return 1;
01338 return 0;
01339 }
01340
01341
01342 static void rv34_decoder_free(RV34DecContext *r)
01343 {
01344 av_freep(&r->intra_types_hist);
01345 r->intra_types = NULL;
01346 av_freep(&r->tmp_b_block_base);
01347 av_freep(&r->mb_type);
01348 av_freep(&r->cbp_luma);
01349 av_freep(&r->cbp_chroma);
01350 av_freep(&r->deblock_coefs);
01351 }
01352
01353
01354 static int rv34_decoder_alloc(RV34DecContext *r)
01355 {
01356 r->intra_types_stride = r->s.mb_width * 4 + 4;
01357
01358 r->cbp_chroma = av_malloc(r->s.mb_stride * r->s.mb_height *
01359 sizeof(*r->cbp_chroma));
01360 r->cbp_luma = av_malloc(r->s.mb_stride * r->s.mb_height *
01361 sizeof(*r->cbp_luma));
01362 r->deblock_coefs = av_malloc(r->s.mb_stride * r->s.mb_height *
01363 sizeof(*r->deblock_coefs));
01364 r->intra_types_hist = av_malloc(r->intra_types_stride * 4 * 2 *
01365 sizeof(*r->intra_types_hist));
01366 r->mb_type = av_mallocz(r->s.mb_stride * r->s.mb_height *
01367 sizeof(*r->mb_type));
01368
01369 if (!(r->cbp_chroma && r->cbp_luma && r->deblock_coefs &&
01370 r->intra_types_hist && r->mb_type)) {
01371 rv34_decoder_free(r);
01372 return AVERROR(ENOMEM);
01373 }
01374
01375 r->intra_types = r->intra_types_hist + r->intra_types_stride * 4;
01376
01377 return 0;
01378 }
01379
01380
01381 static int rv34_decoder_realloc(RV34DecContext *r)
01382 {
01383 rv34_decoder_free(r);
01384 return rv34_decoder_alloc(r);
01385 }
01386
01387
01388 static int rv34_decode_slice(RV34DecContext *r, int end, const uint8_t* buf, int buf_size)
01389 {
01390 MpegEncContext *s = &r->s;
01391 GetBitContext *gb = &s->gb;
01392 int mb_pos, slice_type;
01393 int res;
01394
01395 init_get_bits(&r->s.gb, buf, buf_size*8);
01396 res = r->parse_slice_header(r, gb, &r->si);
01397 if(res < 0){
01398 av_log(s->avctx, AV_LOG_ERROR, "Incorrect or unknown slice header\n");
01399 return -1;
01400 }
01401
01402 slice_type = r->si.type ? r->si.type : AV_PICTURE_TYPE_I;
01403 if (slice_type != s->pict_type) {
01404 av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
01405 return AVERROR_INVALIDDATA;
01406 }
01407 if (s->width != r->si.width || s->height != r->si.height) {
01408 av_log(s->avctx, AV_LOG_ERROR, "Size mismatch\n");
01409 return AVERROR_INVALIDDATA;
01410 }
01411
01412 r->si.end = end;
01413 s->qscale = r->si.quant;
01414 s->mb_num_left = r->si.end - r->si.start;
01415 r->s.mb_skip_run = 0;
01416
01417 mb_pos = s->mb_x + s->mb_y * s->mb_width;
01418 if(r->si.start != mb_pos){
01419 av_log(s->avctx, AV_LOG_ERROR, "Slice indicates MB offset %d, got %d\n", r->si.start, mb_pos);
01420 s->mb_x = r->si.start % s->mb_width;
01421 s->mb_y = r->si.start / s->mb_width;
01422 }
01423 memset(r->intra_types_hist, -1, r->intra_types_stride * 4 * 2 * sizeof(*r->intra_types_hist));
01424 s->first_slice_line = 1;
01425 s->resync_mb_x = s->mb_x;
01426 s->resync_mb_y = s->mb_y;
01427
01428 ff_init_block_index(s);
01429 while(!check_slice_end(r, s)) {
01430 ff_update_block_index(s);
01431
01432 if(r->si.type)
01433 res = rv34_decode_inter_macroblock(r, r->intra_types + s->mb_x * 4 + 4);
01434 else
01435 res = rv34_decode_intra_macroblock(r, r->intra_types + s->mb_x * 4 + 4);
01436 if(res < 0){
01437 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_ERROR);
01438 return -1;
01439 }
01440 if (++s->mb_x == s->mb_width) {
01441 s->mb_x = 0;
01442 s->mb_y++;
01443 ff_init_block_index(s);
01444
01445 memmove(r->intra_types_hist, r->intra_types, r->intra_types_stride * 4 * sizeof(*r->intra_types_hist));
01446 memset(r->intra_types, -1, r->intra_types_stride * 4 * sizeof(*r->intra_types_hist));
01447
01448 if(r->loop_filter && s->mb_y >= 2)
01449 r->loop_filter(r, s->mb_y - 2);
01450
01451 if (HAVE_THREADS && (s->avctx->active_thread_type & FF_THREAD_FRAME))
01452 ff_thread_report_progress(&s->current_picture_ptr->f,
01453 s->mb_y - 2, 0);
01454
01455 }
01456 if(s->mb_x == s->resync_mb_x)
01457 s->first_slice_line=0;
01458 s->mb_num_left--;
01459 }
01460 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_END);
01461
01462 return s->mb_y == s->mb_height;
01463 }
01464
01466
01470 av_cold int ff_rv34_decode_init(AVCodecContext *avctx)
01471 {
01472 RV34DecContext *r = avctx->priv_data;
01473 MpegEncContext *s = &r->s;
01474 int ret;
01475
01476 ff_MPV_decode_defaults(s);
01477 s->avctx = avctx;
01478 s->out_format = FMT_H263;
01479 s->codec_id = avctx->codec_id;
01480
01481 s->width = avctx->width;
01482 s->height = avctx->height;
01483
01484 r->s.avctx = avctx;
01485 avctx->flags |= CODEC_FLAG_EMU_EDGE;
01486 r->s.flags |= CODEC_FLAG_EMU_EDGE;
01487 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
01488 avctx->has_b_frames = 1;
01489 s->low_delay = 0;
01490
01491 if ((ret = ff_MPV_common_init(s)) < 0)
01492 return ret;
01493
01494 ff_h264_pred_init(&r->h, AV_CODEC_ID_RV40, 8, 1);
01495
01496 #if CONFIG_RV30_DECODER
01497 if (avctx->codec_id == AV_CODEC_ID_RV30)
01498 ff_rv30dsp_init(&r->rdsp, &r->s.dsp);
01499 #endif
01500 #if CONFIG_RV40_DECODER
01501 if (avctx->codec_id == AV_CODEC_ID_RV40)
01502 ff_rv40dsp_init(&r->rdsp, &r->s.dsp);
01503 #endif
01504
01505 if ((ret = rv34_decoder_alloc(r)) < 0)
01506 return ret;
01507
01508 if(!intra_vlcs[0].cbppattern[0].bits)
01509 rv34_init_tables();
01510
01511 return 0;
01512 }
01513
01514 int ff_rv34_decode_init_thread_copy(AVCodecContext *avctx)
01515 {
01516 int err;
01517 RV34DecContext *r = avctx->priv_data;
01518
01519 r->s.avctx = avctx;
01520
01521 if (avctx->internal->is_copy) {
01522 r->tmp_b_block_base = NULL;
01523 if ((err = ff_MPV_common_init(&r->s)) < 0)
01524 return err;
01525 if ((err = rv34_decoder_alloc(r)) < 0)
01526 return err;
01527 }
01528 return 0;
01529 }
01530
01531 int ff_rv34_decode_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
01532 {
01533 RV34DecContext *r = dst->priv_data, *r1 = src->priv_data;
01534 MpegEncContext * const s = &r->s, * const s1 = &r1->s;
01535 int err;
01536
01537 if (dst == src || !s1->context_initialized)
01538 return 0;
01539
01540 if (s->height != s1->height || s->width != s1->width) {
01541 s->height = s1->height;
01542 s->width = s1->width;
01543 if ((err = ff_MPV_common_frame_size_change(s)) < 0)
01544 return err;
01545 if ((err = rv34_decoder_realloc(r)) < 0)
01546 return err;
01547 }
01548
01549 if ((err = ff_mpeg_update_thread_context(dst, src)))
01550 return err;
01551
01552 r->cur_pts = r1->cur_pts;
01553 r->last_pts = r1->last_pts;
01554 r->next_pts = r1->next_pts;
01555
01556 memset(&r->si, 0, sizeof(r->si));
01557
01558 return 0;
01559 }
01560
01561 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n)
01562 {
01563 if(avctx->slice_count) return avctx->slice_offset[n];
01564 else return AV_RL32(buf + n*8 - 4) == 1 ? AV_RL32(buf + n*8) : AV_RB32(buf + n*8);
01565 }
01566
01567 static int finish_frame(AVCodecContext *avctx, AVFrame *pict)
01568 {
01569 RV34DecContext *r = avctx->priv_data;
01570 MpegEncContext *s = &r->s;
01571 int got_picture = 0;
01572
01573 ff_er_frame_end(s);
01574 ff_MPV_frame_end(s);
01575 s->mb_num_left = 0;
01576
01577 if (HAVE_THREADS && (s->avctx->active_thread_type & FF_THREAD_FRAME))
01578 ff_thread_report_progress(&s->current_picture_ptr->f, INT_MAX, 0);
01579
01580 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
01581 *pict = s->current_picture_ptr->f;
01582 got_picture = 1;
01583 } else if (s->last_picture_ptr != NULL) {
01584 *pict = s->last_picture_ptr->f;
01585 got_picture = 1;
01586 }
01587 if (got_picture)
01588 ff_print_debug_info(s, pict);
01589
01590 return got_picture;
01591 }
01592
01593 int ff_rv34_decode_frame(AVCodecContext *avctx,
01594 void *data, int *got_picture_ptr,
01595 AVPacket *avpkt)
01596 {
01597 const uint8_t *buf = avpkt->data;
01598 int buf_size = avpkt->size;
01599 RV34DecContext *r = avctx->priv_data;
01600 MpegEncContext *s = &r->s;
01601 AVFrame *pict = data;
01602 SliceInfo si;
01603 int i;
01604 int slice_count;
01605 const uint8_t *slices_hdr = NULL;
01606 int last = 0;
01607
01608
01609 if (buf_size == 0) {
01610
01611 if (s->low_delay==0 && s->next_picture_ptr) {
01612 *pict = s->next_picture_ptr->f;
01613 s->next_picture_ptr = NULL;
01614
01615 *got_picture_ptr = 1;
01616 }
01617 return 0;
01618 }
01619
01620 if(!avctx->slice_count){
01621 slice_count = (*buf++) + 1;
01622 slices_hdr = buf + 4;
01623 buf += 8 * slice_count;
01624 buf_size -= 1 + 8 * slice_count;
01625 }else
01626 slice_count = avctx->slice_count;
01627
01628
01629 if(get_slice_offset(avctx, slices_hdr, 0) < 0 ||
01630 get_slice_offset(avctx, slices_hdr, 0) > buf_size){
01631 av_log(avctx, AV_LOG_ERROR, "Slice offset is invalid\n");
01632 return AVERROR_INVALIDDATA;
01633 }
01634 init_get_bits(&s->gb, buf+get_slice_offset(avctx, slices_hdr, 0), (buf_size-get_slice_offset(avctx, slices_hdr, 0))*8);
01635 if(r->parse_slice_header(r, &r->s.gb, &si) < 0 || si.start){
01636 av_log(avctx, AV_LOG_ERROR, "First slice header is incorrect\n");
01637 return AVERROR_INVALIDDATA;
01638 }
01639 if ((!s->last_picture_ptr || !s->last_picture_ptr->f.data[0]) &&
01640 si.type == AV_PICTURE_TYPE_B) {
01641 av_log(avctx, AV_LOG_ERROR, "Invalid decoder state: B-frame without "
01642 "reference data.\n");
01643 return AVERROR_INVALIDDATA;
01644 }
01645 if( (avctx->skip_frame >= AVDISCARD_NONREF && si.type==AV_PICTURE_TYPE_B)
01646 || (avctx->skip_frame >= AVDISCARD_NONKEY && si.type!=AV_PICTURE_TYPE_I)
01647 || avctx->skip_frame >= AVDISCARD_ALL)
01648 return avpkt->size;
01649
01650
01651 if (si.start == 0) {
01652 if (s->mb_num_left > 0) {
01653 av_log(avctx, AV_LOG_ERROR, "New frame but still %d MB left.\n",
01654 s->mb_num_left);
01655 ff_er_frame_end(s);
01656 ff_MPV_frame_end(s);
01657 }
01658
01659 if (s->width != si.width || s->height != si.height) {
01660 int err;
01661
01662 av_log(s->avctx, AV_LOG_WARNING, "Changing dimensions to %dx%d\n",
01663 si.width, si.height);
01664
01665 if (av_image_check_size(si.width, si.height, 0, s->avctx))
01666 return AVERROR_INVALIDDATA;
01667
01668 s->width = si.width;
01669 s->height = si.height;
01670 avcodec_set_dimensions(s->avctx, s->width, s->height);
01671 if ((err = ff_MPV_common_frame_size_change(s)) < 0)
01672 return err;
01673 if ((err = rv34_decoder_realloc(r)) < 0)
01674 return err;
01675 }
01676 s->pict_type = si.type ? si.type : AV_PICTURE_TYPE_I;
01677 if (ff_MPV_frame_start(s, s->avctx) < 0)
01678 return -1;
01679 ff_er_frame_start(s);
01680 if (!r->tmp_b_block_base) {
01681 int i;
01682
01683 r->tmp_b_block_base = av_malloc(s->linesize * 48);
01684 for (i = 0; i < 2; i++)
01685 r->tmp_b_block_y[i] = r->tmp_b_block_base
01686 + i * 16 * s->linesize;
01687 for (i = 0; i < 4; i++)
01688 r->tmp_b_block_uv[i] = r->tmp_b_block_base + 32 * s->linesize
01689 + (i >> 1) * 8 * s->uvlinesize
01690 + (i & 1) * 16;
01691 }
01692 r->cur_pts = si.pts;
01693 if (s->pict_type != AV_PICTURE_TYPE_B) {
01694 r->last_pts = r->next_pts;
01695 r->next_pts = r->cur_pts;
01696 } else {
01697 int refdist = GET_PTS_DIFF(r->next_pts, r->last_pts);
01698 int dist0 = GET_PTS_DIFF(r->cur_pts, r->last_pts);
01699 int dist1 = GET_PTS_DIFF(r->next_pts, r->cur_pts);
01700
01701 if(!refdist){
01702 r->mv_weight1 = r->mv_weight2 = r->weight1 = r->weight2 = 8192;
01703 r->scaled_weight = 0;
01704 }else{
01705 r->mv_weight1 = (dist0 << 14) / refdist;
01706 r->mv_weight2 = (dist1 << 14) / refdist;
01707 if((r->mv_weight1|r->mv_weight2) & 511){
01708 r->weight1 = r->mv_weight1;
01709 r->weight2 = r->mv_weight2;
01710 r->scaled_weight = 0;
01711 }else{
01712 r->weight1 = r->mv_weight1 >> 9;
01713 r->weight2 = r->mv_weight2 >> 9;
01714 r->scaled_weight = 1;
01715 }
01716 }
01717 }
01718 s->mb_x = s->mb_y = 0;
01719 ff_thread_finish_setup(s->avctx);
01720 } else if (HAVE_THREADS &&
01721 (s->avctx->active_thread_type & FF_THREAD_FRAME)) {
01722 av_log(s->avctx, AV_LOG_ERROR, "Decoder needs full frames in frame "
01723 "multithreading mode (start MB is %d).\n", si.start);
01724 return AVERROR_INVALIDDATA;
01725 }
01726
01727 for(i = 0; i < slice_count; i++){
01728 int offset = get_slice_offset(avctx, slices_hdr, i);
01729 int size;
01730 if(i+1 == slice_count)
01731 size = buf_size - offset;
01732 else
01733 size = get_slice_offset(avctx, slices_hdr, i+1) - offset;
01734
01735 if(offset < 0 || offset > buf_size){
01736 av_log(avctx, AV_LOG_ERROR, "Slice offset is invalid\n");
01737 break;
01738 }
01739
01740 r->si.end = s->mb_width * s->mb_height;
01741 s->mb_num_left = r->s.mb_x + r->s.mb_y*r->s.mb_width - r->si.start;
01742
01743 if(i+1 < slice_count){
01744 if (get_slice_offset(avctx, slices_hdr, i+1) < 0 ||
01745 get_slice_offset(avctx, slices_hdr, i+1) > buf_size) {
01746 av_log(avctx, AV_LOG_ERROR, "Slice offset is invalid\n");
01747 break;
01748 }
01749 init_get_bits(&s->gb, buf+get_slice_offset(avctx, slices_hdr, i+1), (buf_size-get_slice_offset(avctx, slices_hdr, i+1))*8);
01750 if(r->parse_slice_header(r, &r->s.gb, &si) < 0){
01751 if(i+2 < slice_count)
01752 size = get_slice_offset(avctx, slices_hdr, i+2) - offset;
01753 else
01754 size = buf_size - offset;
01755 }else
01756 r->si.end = si.start;
01757 }
01758 if (size < 0 || size > buf_size - offset) {
01759 av_log(avctx, AV_LOG_ERROR, "Slice size is invalid\n");
01760 break;
01761 }
01762 last = rv34_decode_slice(r, r->si.end, buf + offset, size);
01763 if(last)
01764 break;
01765 }
01766
01767 if (s->current_picture_ptr) {
01768 if (last) {
01769 if(r->loop_filter)
01770 r->loop_filter(r, s->mb_height - 1);
01771
01772 *got_picture_ptr = finish_frame(avctx, pict);
01773 } else if (HAVE_THREADS &&
01774 (s->avctx->active_thread_type & FF_THREAD_FRAME)) {
01775 av_log(avctx, AV_LOG_INFO, "marking unfished frame as finished\n");
01776
01777
01778 ff_er_frame_end(s);
01779 ff_MPV_frame_end(s);
01780 s->mb_num_left = 0;
01781 ff_thread_report_progress(&s->current_picture_ptr->f, INT_MAX, 0);
01782 return AVERROR_INVALIDDATA;
01783 }
01784 }
01785
01786 return avpkt->size;
01787 }
01788
01789 av_cold int ff_rv34_decode_end(AVCodecContext *avctx)
01790 {
01791 RV34DecContext *r = avctx->priv_data;
01792
01793 ff_MPV_common_end(&r->s);
01794 rv34_decoder_free(r);
01795
01796 return 0;
01797 }