← Back to branch summary

~ubuntu-branches/ubuntu/trusty/gst-libav1.0/trusty-proposed

« back to all changes in this revision

Viewing changes to gst-libs/ext/libav/libavcodec/vc1dec.c

  • Committer: Package Import Robot
  • Author(s): Sebastian Dröge
  • Date: 2013-09-24 17:07:00 UTC
  • mfrom: (1.1.17) (7.1.9 experimental)
  • Revision ID: package-import@ubuntu.com-20130924170700-4dg62s3pwl0pdakz
Tags: 1.2.0-1
* New upstream stable release:
  + debian/control:
    - Build depend on GStreamer and gst-plugins-base >= 1.2.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
gst-libs/ext/libav/libavcodec/vc1dec.c
36
36
#include "vc1acdata.h"
37
37
#include "msmpeg4data.h"
38
38
#include "unary.h"
39
 
#include "simple_idct.h"
40
39
#include "mathops.h"
41
40
#include "vdpau_internal.h"
42
41
 
395
394
        }
396
395
    }
397
396
 
 
397
    if (!srcY || !srcU) {
 
398
        av_log(v->s.avctx, AV_LOG_ERROR, "Referenced frame missing.\n");
 
399
        return;
 
400
    }
 
401
 
398
402
    src_x   = s->mb_x * 16 + (mx   >> 2);
399
403
    src_y   = s->mb_y * 16 + (my   >> 2);
400
404
    uvsrc_x = s->mb_x *  8 + (uvmx >> 2);
431
435
    if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
432
436
        || s->h_edge_pos < 22 || v_edge_pos < 22
433
437
        || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx&3) - 16 - s->mspel * 3
434
 
        || (unsigned)(src_y - s->mspel) > v_edge_pos    - (my&3) - 16 - s->mspel * 3) {
 
438
        || (unsigned)(src_y - 1)        > v_edge_pos    - (my&3) - 16 - 3) {
435
439
        uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
436
440
 
437
441
        srcY -= s->mspel * (1 + s->linesize);
438
 
        s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
439
 
                                17 + s->mspel * 2, 17 + s->mspel * 2,
440
 
                                src_x - s->mspel, src_y - s->mspel,
441
 
                                s->h_edge_pos, v_edge_pos);
 
442
        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
 
443
                                 17 + s->mspel * 2, 17 + s->mspel * 2,
 
444
                                 src_x - s->mspel, src_y - s->mspel,
 
445
                                 s->h_edge_pos, v_edge_pos);
442
446
        srcY = s->edge_emu_buffer;
443
 
        s->dsp.emulated_edge_mc(uvbuf     , srcU, s->uvlinesize, 8 + 1, 8 + 1,
444
 
                                uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
445
 
        s->dsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
446
 
                                uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
 
447
        s->vdsp.emulated_edge_mc(uvbuf     , srcU, s->uvlinesize, 8 + 1, 8 + 1,
 
448
                                 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
 
449
        s->vdsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
 
450
                                 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
447
451
        srcU = uvbuf;
448
452
        srcV = uvbuf + 16;
449
453
        /* if we deal with range reduction we need to scale source blocks */
570
574
    } else
571
575
        srcY = s->next_picture.f.data[0];
572
576
 
 
577
    if (!srcY) {
 
578
        av_log(v->s.avctx, AV_LOG_ERROR, "Referenced frame missing.\n");
 
579
        return;
 
580
    }
 
581
 
573
582
    if (v->field_mode) {
574
583
        if (v->cur_field_type != v->ref_field_type[dir])
575
584
            my = my - 2 + 4 * v->cur_field_type;
668
677
        || (unsigned)(src_y - (s->mspel << fieldmv)) > v_edge_pos - (my & 3) - ((8 + s->mspel * 2) << fieldmv)) {
669
678
        srcY -= s->mspel * (1 + (s->linesize << fieldmv));
670
679
        /* check emulate edge stride and offset */
671
 
        s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
672
 
                                9 + s->mspel * 2, (9 + s->mspel * 2) << fieldmv,
673
 
                                src_x - s->mspel, src_y - (s->mspel << fieldmv),
674
 
                                s->h_edge_pos, v_edge_pos);
 
680
        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
 
681
                                 9 + s->mspel * 2, (9 + s->mspel * 2) << fieldmv,
 
682
                                 src_x - s->mspel, src_y - (s->mspel << fieldmv),
 
683
                                 s->h_edge_pos, v_edge_pos);
675
684
        srcY = s->edge_emu_buffer;
676
685
        /* if we deal with range reduction we need to scale source blocks */
677
686
        if (v->rangeredfrm) {
795
804
    /* calculate chroma MV vector from four luma MVs */
796
805
    if (!v->field_mode || (v->field_mode && !v->numref)) {
797
806
        valid_count = get_chroma_mv(mvx, mvy, intra, 0, &tx, &ty);
 
807
        chroma_ref_type = v->reffield;
798
808
        if (!valid_count) {
799
809
            s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
800
810
            s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
856
866
        srcV = s->next_picture.f.data[2] + uvsrc_y * s->uvlinesize + uvsrc_x;
857
867
    }
858
868
 
 
869
    if (!srcU) {
 
870
        av_log(v->s.avctx, AV_LOG_ERROR, "Referenced frame missing.\n");
 
871
        return;
 
872
    }
 
873
 
859
874
    if (v->field_mode) {
860
875
        if (chroma_ref_type) {
861
876
            srcU += s->current_picture_ptr->f.linesize[1];
868
883
        || s->h_edge_pos < 18 || v_edge_pos < 18
869
884
        || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
870
885
        || (unsigned)uvsrc_y > (v_edge_pos    >> 1) - 9) {
871
 
        s->dsp.emulated_edge_mc(s->edge_emu_buffer     , srcU, s->uvlinesize,
872
 
                                8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
873
 
                                s->h_edge_pos >> 1, v_edge_pos >> 1);
874
 
        s->dsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
875
 
                                8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
876
 
                                s->h_edge_pos >> 1, v_edge_pos >> 1);
 
886
        s->vdsp.emulated_edge_mc(s->edge_emu_buffer     , srcU, s->uvlinesize,
 
887
                                 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
 
888
                                 s->h_edge_pos >> 1, v_edge_pos >> 1);
 
889
        s->vdsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
 
890
                                 8 + 1, 8 + 1, uvsrc_x, uvsrc_y,
 
891
                                 s->h_edge_pos >> 1, v_edge_pos >> 1);
877
892
        srcU = s->edge_emu_buffer;
878
893
        srcV = s->edge_emu_buffer + 16;
879
894
 
973
988
            || s->h_edge_pos < 10 || v_edge_pos < (5 << fieldmv)
974
989
            || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 5
975
990
            || (unsigned)uvsrc_y > v_edge_pos - (5 << fieldmv)) {
976
 
            s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcU, s->uvlinesize,
977
 
                                    5, (5 << fieldmv), uvsrc_x, uvsrc_y,
978
 
                                    s->h_edge_pos >> 1, v_edge_pos);
979
 
            s->dsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
980
 
                                    5, (5 << fieldmv), uvsrc_x, uvsrc_y,
981
 
                                    s->h_edge_pos >> 1, v_edge_pos);
 
991
            s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcU, s->uvlinesize,
 
992
                                     5, (5 << fieldmv), uvsrc_x, uvsrc_y,
 
993
                                     s->h_edge_pos >> 1, v_edge_pos);
 
994
            s->vdsp.emulated_edge_mc(s->edge_emu_buffer + 16, srcV, s->uvlinesize,
 
995
                                     5, (5 << fieldmv), uvsrc_x, uvsrc_y,
 
996
                                     s->h_edge_pos >> 1, v_edge_pos);
982
997
            srcU = s->edge_emu_buffer;
983
998
            srcV = s->edge_emu_buffer + 16;
984
999
 
1048
1063
            mquant = v->altpq;                                 \
1049
1064
        if ((edges&8) && s->mb_y == (s->mb_height - 1))        \
1050
1065
            mquant = v->altpq;                                 \
 
1066
        if (!mquant || mquant > 31) {                          \
 
1067
            av_log(v->s.avctx, AV_LOG_ERROR,                   \
 
1068
                   "Overriding invalid mquant %d\n", mquant);  \
 
1069
            mquant = 1;                                        \
 
1070
        }                                                      \
1051
1071
    }
1052
1072
 
1053
1073
/**
1128
1148
        *dmv_x = get_bits(gb, v->k_x);
1129
1149
        *dmv_y = get_bits(gb, v->k_y);
1130
1150
        if (v->numref) {
1131
 
            *pred_flag = *dmv_y & 1;
1132
 
            *dmv_y     = (*dmv_y + *pred_flag) >> 1;
 
1151
            if (pred_flag) {
 
1152
                *pred_flag = *dmv_y & 1;
 
1153
                *dmv_y     = (*dmv_y + *pred_flag) >> 1;
 
1154
            } else {
 
1155
                *dmv_y     = (*dmv_y + (*dmv_y & 1)) >> 1;
 
1156
            }
1133
1157
        }
1134
1158
    }
1135
1159
    else {
1155
1179
            *dmv_y = (sign ^ ((val >> 1) + offs_tab[index1 >> v->numref])) - sign;
1156
1180
        } else
1157
1181
            *dmv_y = 0;
1158
 
        if (v->numref)
 
1182
        if (v->numref && pred_flag)
1159
1183
            *pred_flag = index1 & 1;
1160
1184
    }
1161
1185
}
1173
1197
        refdist = dir ? v->brfd : v->frfd;
1174
1198
    if (refdist > 3)
1175
1199
        refdist = 3;
1176
 
    scalesame1    = vc1_field_mvpred_scales[table_index][1][refdist];
1177
 
    scalesame2    = vc1_field_mvpred_scales[table_index][2][refdist];
1178
 
    scalezone1_x  = vc1_field_mvpred_scales[table_index][3][refdist];
1179
 
    zone1offset_x = vc1_field_mvpred_scales[table_index][5][refdist];
 
1200
    scalesame1    = ff_vc1_field_mvpred_scales[table_index][1][refdist];
 
1201
    scalesame2    = ff_vc1_field_mvpred_scales[table_index][2][refdist];
 
1202
    scalezone1_x  = ff_vc1_field_mvpred_scales[table_index][3][refdist];
 
1203
    zone1offset_x = ff_vc1_field_mvpred_scales[table_index][5][refdist];
1180
1204
 
1181
1205
    if (FFABS(n) > 255)
1182
1206
        scaledvalue = n;
1206
1230
        refdist = dir ? v->brfd : v->frfd;
1207
1231
    if (refdist > 3)
1208
1232
        refdist = 3;
1209
 
    scalesame1    = vc1_field_mvpred_scales[table_index][1][refdist];
1210
 
    scalesame2    = vc1_field_mvpred_scales[table_index][2][refdist];
1211
 
    scalezone1_y  = vc1_field_mvpred_scales[table_index][4][refdist];
1212
 
    zone1offset_y = vc1_field_mvpred_scales[table_index][6][refdist];
 
1233
    scalesame1    = ff_vc1_field_mvpred_scales[table_index][1][refdist];
 
1234
    scalesame2    = ff_vc1_field_mvpred_scales[table_index][2][refdist];
 
1235
    scalezone1_y  = ff_vc1_field_mvpred_scales[table_index][4][refdist];
 
1236
    zone1offset_y = ff_vc1_field_mvpred_scales[table_index][6][refdist];
1213
1237
 
1214
1238
    if (FFABS(n) > 63)
1215
1239
        scaledvalue = n;
1237
1261
    int scaledvalue;
1238
1262
 
1239
1263
    brfd = FFMIN(v->brfd, 3);
1240
 
    scalezone1_x  = vc1_b_field_mvpred_scales[3][brfd];
1241
 
    zone1offset_x = vc1_b_field_mvpred_scales[5][brfd];
1242
 
    scaleopp1     = vc1_b_field_mvpred_scales[1][brfd];
1243
 
    scaleopp2     = vc1_b_field_mvpred_scales[2][brfd];
 
1264
    scalezone1_x  = ff_vc1_b_field_mvpred_scales[3][brfd];
 
1265
    zone1offset_x = ff_vc1_b_field_mvpred_scales[5][brfd];
 
1266
    scaleopp1     = ff_vc1_b_field_mvpred_scales[1][brfd];
 
1267
    scaleopp2     = ff_vc1_b_field_mvpred_scales[2][brfd];
1244
1268
 
1245
1269
    if (FFABS(n) > 255)
1246
1270
        scaledvalue = n;
1264
1288
    int scaledvalue;
1265
1289
 
1266
1290
    brfd = FFMIN(v->brfd, 3);
1267
 
    scalezone1_y  = vc1_b_field_mvpred_scales[4][brfd];
1268
 
    zone1offset_y = vc1_b_field_mvpred_scales[6][brfd];
1269
 
    scaleopp1     = vc1_b_field_mvpred_scales[1][brfd];
1270
 
    scaleopp2     = vc1_b_field_mvpred_scales[2][brfd];
 
1291
    scalezone1_y  = ff_vc1_b_field_mvpred_scales[4][brfd];
 
1292
    zone1offset_y = ff_vc1_b_field_mvpred_scales[6][brfd];
 
1293
    scaleopp1     = ff_vc1_b_field_mvpred_scales[1][brfd];
 
1294
    scaleopp2     = ff_vc1_b_field_mvpred_scales[2][brfd];
1271
1295
 
1272
1296
    if (FFABS(n) > 63)
1273
1297
        scaledvalue = n;
1303
1327
        return n;
1304
1328
    }
1305
1329
    brfd      = FFMIN(v->brfd, 3);
1306
 
    scalesame = vc1_b_field_mvpred_scales[0][brfd];
 
1330
    scalesame = ff_vc1_b_field_mvpred_scales[0][brfd];
1307
1331
 
1308
1332
    n = (n * scalesame >> 8) << hpel;
1309
1333
    return n;
1327
1351
        refdist = FFMIN(v->refdist, 3);
1328
1352
    else
1329
1353
        refdist = dir ? v->brfd : v->frfd;
1330
 
    scaleopp = vc1_field_mvpred_scales[dir ^ v->second_field][0][refdist];
 
1354
    scaleopp = ff_vc1_field_mvpred_scales[dir ^ v->second_field][0][refdist];
1331
1355
 
1332
1356
    n = (n * scaleopp >> 8) << hpel;
1333
1357
    return n;
1345
1369
    int px, py;
1346
1370
    int sum;
1347
1371
    int mixedmv_pic, num_samefield = 0, num_oppfield = 0;
1348
 
    int opposit, a_f, b_f, c_f;
 
1372
    int opposite, a_f, b_f, c_f;
1349
1373
    int16_t field_predA[2];
1350
1374
    int16_t field_predB[2];
1351
1375
    int16_t field_predC[2];
1453
1477
    }
1454
1478
 
1455
1479
    if (v->field_mode) {
1456
 
        if (num_samefield <= num_oppfield)
1457
 
            opposit = 1 - pred_flag;
1458
 
        else
1459
 
            opposit = pred_flag;
 
1480
        if (!v->numref)
 
1481
            // REFFIELD determines if the last field or the second-last field is
 
1482
            // to be used as reference
 
1483
            opposite = 1 - v->reffield;
 
1484
        else {
 
1485
            if (num_samefield <= num_oppfield)
 
1486
                opposite = 1 - pred_flag;
 
1487
            else
 
1488
                opposite = pred_flag;
 
1489
        }
1460
1490
    } else
1461
 
        opposit = 0;
1462
 
    if (opposit) {
 
1491
        opposite = 0;
 
1492
    if (opposite) {
1463
1493
        if (a_valid && !a_f) {
1464
1494
            field_predA[0] = scaleforopp(v, field_predA[0], 0, dir);
1465
1495
            field_predA[1] = scaleforopp(v, field_predA[1], 1, dir);
1562
1592
        }
1563
1593
    }
1564
1594
 
1565
 
    if (v->field_mode && !s->quarter_sample) {
1566
 
        r_x <<= 1;
1567
 
        r_y <<= 1;
1568
 
    }
1569
1595
    if (v->field_mode && v->numref)
1570
1596
        r_y >>= 1;
1571
1597
    if (v->field_mode && v->cur_field_type && v->ref_field_type[dir] == 0)
1876
1902
    }
1877
1903
 
1878
1904
    if (v->rangeredfrm || s->h_edge_pos < 22 || v_edge_pos < 22
1879
 
        || (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx & 3) - 16 - s->mspel * 3
1880
 
        || (unsigned)(src_y - s->mspel) > v_edge_pos    - (my & 3) - 16 - s->mspel * 3) {
 
1905
        || (unsigned)(src_x - 1) > s->h_edge_pos - (mx & 3) - 16 - 3
 
1906
        || (unsigned)(src_y - 1) > v_edge_pos    - (my & 3) - 16 - 3) {
1881
1907
        uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
1882
1908
 
1883
1909
        srcY -= s->mspel * (1 + s->linesize);
1884
 
        s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
1885
 
                                17 + s->mspel * 2, 17 + s->mspel * 2,
1886
 
                                src_x - s->mspel, src_y - s->mspel,
1887
 
                                s->h_edge_pos, v_edge_pos);
 
1910
        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
 
1911
                                 17 + s->mspel * 2, 17 + s->mspel * 2,
 
1912
                                 src_x - s->mspel, src_y - s->mspel,
 
1913
                                 s->h_edge_pos, v_edge_pos);
1888
1914
        srcY = s->edge_emu_buffer;
1889
 
        s->dsp.emulated_edge_mc(uvbuf     , srcU, s->uvlinesize, 8 + 1, 8 + 1,
1890
 
                                uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
1891
 
        s->dsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
1892
 
                                uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
 
1915
        s->vdsp.emulated_edge_mc(uvbuf     , srcU, s->uvlinesize, 8 + 1, 8 + 1,
 
1916
                                 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
 
1917
        s->vdsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
 
1918
                                 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
1893
1919
        srcU = uvbuf;
1894
1920
        srcV = uvbuf + 16;
1895
1921
        /* if we deal with range reduction we need to scale source blocks */
1973
1999
#endif
1974
2000
}
1975
2001
 
1976
 
static av_always_inline int scale_mv_intfi(int value, int bfrac, int inv,
1977
 
                                           int qs, int qs_last)
1978
 
{
1979
 
    int n = bfrac;
1980
 
 
1981
 
    if (inv)
1982
 
        n -= 256;
1983
 
    n <<= !qs_last;
1984
 
    if (!qs)
1985
 
        return (value * n + 255) >> 9;
1986
 
    else
1987
 
        return (value * n + 128) >> 8;
1988
 
}
1989
 
 
1990
2002
/** Reconstruct motion vector for B-frame and do motion compensation
1991
2003
 */
1992
2004
static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2],
2240
2252
    if (v->bmvtype == BMV_TYPE_DIRECT) {
2241
2253
        int total_opp, k, f;
2242
2254
        if (s->next_picture.f.mb_type[mb_pos + v->mb_off] != MB_TYPE_INTRA) {
2243
 
            s->mv[0][0][0] = scale_mv_intfi(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0],
2244
 
                                            v->bfraction, 0, s->quarter_sample, v->qs_last);
2245
 
            s->mv[0][0][1] = scale_mv_intfi(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1],
2246
 
                                            v->bfraction, 0, s->quarter_sample, v->qs_last);
2247
 
            s->mv[1][0][0] = scale_mv_intfi(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0],
2248
 
                                            v->bfraction, 1, s->quarter_sample, v->qs_last);
2249
 
            s->mv[1][0][1] = scale_mv_intfi(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1],
2250
 
                                            v->bfraction, 1, s->quarter_sample, v->qs_last);
 
2255
            s->mv[0][0][0] = scale_mv(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0],
 
2256
                                      v->bfraction, 0, s->quarter_sample);
 
2257
            s->mv[0][0][1] = scale_mv(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1],
 
2258
                                      v->bfraction, 0, s->quarter_sample);
 
2259
            s->mv[1][0][0] = scale_mv(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0],
 
2260
                                      v->bfraction, 1, s->quarter_sample);
 
2261
            s->mv[1][0][1] = scale_mv(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1],
 
2262
                                      v->bfraction, 1, s->quarter_sample);
2251
2263
 
2252
2264
            total_opp = v->mv_f_next[0][s->block_index[0] + v->blocks_off]
2253
2265
                      + v->mv_f_next[0][s->block_index[1] + v->blocks_off]
3835
3847
                vc1_mc_4mv_chroma4(v);
3836
3848
            } else {
3837
3849
                mvbp = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][2];
 
3850
                dmv_x = dmv_y = 0;
3838
3851
                if (mvbp) {
3839
3852
                    get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3840
3853
                }
3949
3962
        s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
3950
3963
        for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
3951
3964
        if (idx_mbmode <= 5) { // 1-MV
3952
 
            dmv_x = dmv_y = 0;
 
3965
            dmv_x = dmv_y = pred_flag = 0;
3953
3966
            if (idx_mbmode & 1) {
3954
3967
                get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
3955
3968
            }
4357
4370
    s->mb_x = s->mb_y = 0;
4358
4371
    s->mb_intra         = 1;
4359
4372
    s->first_slice_line = 1;
4360
 
    for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
 
4373
    for (s->mb_y = 0; s->mb_y < s->end_mb_y; s->mb_y++) {
4361
4374
        s->mb_x = 0;
4362
4375
        ff_init_block_index(s);
4363
 
        for (; s->mb_x < s->mb_width; s->mb_x++) {
 
4376
        for (; s->mb_x < v->end_mb_x; s->mb_x++) {
4364
4377
            uint8_t *dst[6];
4365
4378
            ff_update_block_index(s);
4366
4379
            dst[0] = s->dest[0];
4447
4460
        s->first_slice_line = 0;
4448
4461
    }
4449
4462
    if (v->s.loop_filter)
4450
 
        ff_draw_horiz_band(s, (s->mb_height - 1) * 16, 16);
 
4463
        ff_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
 
4464
 
 
4465
    /* This is intentionally mb_height and not end_mb_y - unlike in advanced
 
4466
     * profile, these only differ are when decoding MSS2 rectangles. */
4451
4467
    ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, ER_MB_END);
4452
4468
}
4453
4469
 
4741
4757
    s->pict_type = AV_PICTURE_TYPE_P;
4742
4758
}
4743
4759
 
4744
 
static void vc1_decode_blocks(VC1Context *v)
 
4760
void ff_vc1_decode_blocks(VC1Context *v)
4745
4761
{
4746
4762
 
4747
4763
    v->s.esc3_level_length = 0;
4899
4915
        av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
4900
4916
 
4901
4917
    if (get_bits_count(gb) >= gb->size_in_bits +
4902
 
       (avctx->codec_id == CODEC_ID_WMV3IMAGE ? 64 : 0))
 
4918
       (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0))
4903
4919
        av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
4904
4920
    if (get_bits_count(gb) < gb->size_in_bits - 8)
4905
4921
        av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
4937
4953
                int      iline  = s->current_picture.f.linesize[plane];
4938
4954
                int      ycoord = yoff[sprite] + yadv[sprite] * row;
4939
4955
                int      yline  = ycoord >> 16;
 
4956
                int      next_line;
4940
4957
                ysub[sprite] = ycoord & 0xFFFF;
4941
4958
                if (sprite) {
4942
4959
                    iplane = s->last_picture.f.data[plane];
4943
4960
                    iline  = s->last_picture.f.linesize[plane];
4944
4961
                }
 
4962
                next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
4945
4963
                if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
4946
4964
                        src_h[sprite][0] = iplane + (xoff[sprite] >> 16) +  yline      * iline;
4947
4965
                    if (ysub[sprite])
4948
 
                        src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + (yline + 1) * iline;
 
4966
                        src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
4949
4967
                } else {
4950
4968
                    if (sr_cache[sprite][0] != yline) {
4951
4969
                        if (sr_cache[sprite][1] == yline) {
4957
4975
                        }
4958
4976
                    }
4959
4977
                    if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
4960
 
                        v->vc1dsp.sprite_h(v->sr_rows[sprite][1], iplane + (yline + 1) * iline, xoff[sprite], xadv[sprite], width);
 
4978
                        v->vc1dsp.sprite_h(v->sr_rows[sprite][1],
 
4979
                                           iplane + next_line, xoff[sprite],
 
4980
                                           xadv[sprite], width);
4961
4981
                        sr_cache[sprite][1] = yline + 1;
4962
4982
                    }
4963
4983
                    src_h[sprite][0] = v->sr_rows[sprite][0];
5021
5041
 
5022
5042
    v->sprite_output_frame.buffer_hints = FF_BUFFER_HINTS_VALID;
5023
5043
    v->sprite_output_frame.reference = 0;
5024
 
    if (avctx->get_buffer(avctx, &v->sprite_output_frame) < 0) {
 
5044
    if (ff_get_buffer(avctx, &v->sprite_output_frame) < 0) {
5025
5045
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
5026
5046
        return -1;
5027
5047
    }
5051
5071
 
5052
5072
#endif
5053
5073
 
5054
 
static av_cold int vc1_decode_init_alloc_tables(VC1Context *v)
 
5074
av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
5055
5075
{
5056
5076
    MpegEncContext *s = &v->s;
5057
5077
    int i;
5104
5124
 
5105
5125
    ff_intrax8_common_init(&v->x8,s);
5106
5126
 
5107
 
    if (s->avctx->codec_id == CODEC_ID_WMV3IMAGE || s->avctx->codec_id == CODEC_ID_VC1IMAGE) {
 
5127
    if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5108
5128
        for (i = 0; i < 4; i++)
5109
5129
            if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width))) return -1;
5110
5130
    }
5117
5137
    return 0;
5118
5138
}
5119
5139
 
 
5140
av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
 
5141
{
 
5142
    int i;
 
5143
    for (i = 0; i < 64; i++) {
 
5144
#define transpose(x) ((x >> 3) | ((x & 7) << 3))
 
5145
        v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
 
5146
        v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
 
5147
        v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
 
5148
        v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
 
5149
        v->zzi_8x8[i]   = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
 
5150
    }
 
5151
    v->left_blk_sh = 0;
 
5152
    v->top_blk_sh  = 3;
 
5153
}
 
5154
 
5120
5155
/** Initialize a VC1/WMV3 decoder
5121
5156
 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5122
5157
 * @todo TODO: Decypher remaining bits in extra_data
5126
5161
    VC1Context *v = avctx->priv_data;
5127
5162
    MpegEncContext *s = &v->s;
5128
5163
    GetBitContext gb;
5129
 
    int i;
5130
5164
 
5131
5165
    /* save the container output size for WMImage */
5132
5166
    v->output_width  = avctx->width;
5137
5171
    if (!(avctx->flags & CODEC_FLAG_GRAY))
5138
5172
        avctx->pix_fmt = avctx->get_format(avctx, avctx->codec->pix_fmts);
5139
5173
    else
5140
 
        avctx->pix_fmt = PIX_FMT_GRAY8;
 
5174
        avctx->pix_fmt = AV_PIX_FMT_GRAY8;
5141
5175
    avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
5142
5176
    v->s.avctx = avctx;
5143
5177
    avctx->flags |= CODEC_FLAG_EMU_EDGE;
5151
5185
        return -1;
5152
5186
    ff_vc1dsp_init(&v->vc1dsp);
5153
5187
 
5154
 
    if (avctx->codec_id == CODEC_ID_WMV3 || avctx->codec_id == CODEC_ID_WMV3IMAGE) {
 
5188
    if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
5155
5189
        int count = 0;
5156
5190
 
5157
5191
        // looks like WMV3 has a sequence header stored in the extradata
5161
5195
 
5162
5196
        init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
5163
5197
 
5164
 
        if (vc1_decode_sequence_header(avctx, v, &gb) < 0)
 
5198
        if (ff_vc1_decode_sequence_header(avctx, v, &gb) < 0)
5165
5199
          return -1;
5166
5200
 
5167
5201
        count = avctx->extradata_size*8 - get_bits_count(&gb);
5196
5230
            init_get_bits(&gb, buf2, buf2_size * 8);
5197
5231
            switch (AV_RB32(start)) {
5198
5232
            case VC1_CODE_SEQHDR:
5199
 
                if (vc1_decode_sequence_header(avctx, v, &gb) < 0) {
 
5233
                if (ff_vc1_decode_sequence_header(avctx, v, &gb) < 0) {
5200
5234
                    av_free(buf2);
5201
5235
                    return -1;
5202
5236
                }
5203
5237
                seq_initialized = 1;
5204
5238
                break;
5205
5239
            case VC1_CODE_ENTRYPOINT:
5206
 
                if (vc1_decode_entry_point(avctx, v, &gb) < 0) {
 
5240
                if (ff_vc1_decode_entry_point(avctx, v, &gb) < 0) {
5207
5241
                    av_free(buf2);
5208
5242
                    return -1;
5209
5243
                }
5229
5263
    s->mb_height = (avctx->coded_height + 15) >> 4;
5230
5264
 
5231
5265
    if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
5232
 
        for (i = 0; i < 64; i++) {
5233
 
#define transpose(x) ((x >> 3) | ((x & 7) << 3))
5234
 
            v->zz_8x8[0][i] = transpose(wmv1_scantable[0][i]);
5235
 
            v->zz_8x8[1][i] = transpose(wmv1_scantable[1][i]);
5236
 
            v->zz_8x8[2][i] = transpose(wmv1_scantable[2][i]);
5237
 
            v->zz_8x8[3][i] = transpose(wmv1_scantable[3][i]);
5238
 
            v->zzi_8x8[i] = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
5239
 
        }
5240
 
        v->left_blk_sh = 0;
5241
 
        v->top_blk_sh  = 3;
 
5266
        ff_vc1_init_transposed_scantables(v);
5242
5267
    } else {
5243
 
        memcpy(v->zz_8x8, wmv1_scantable, 4*64);
 
5268
        memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
5244
5269
        v->left_blk_sh = 3;
5245
5270
        v->top_blk_sh  = 0;
5246
5271
    }
5247
5272
 
5248
 
    if (avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE) {
 
5273
    if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5249
5274
        v->sprite_width  = avctx->coded_width;
5250
5275
        v->sprite_height = avctx->coded_height;
5251
5276
 
5264
5289
/** Close a VC1/WMV3 decoder
5265
5290
 * @warning Initial try at using MpegEncContext stuff
5266
5291
 */
5267
 
static av_cold int vc1_decode_end(AVCodecContext *avctx)
 
5292
av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
5268
5293
{
5269
5294
    VC1Context *v = avctx->priv_data;
5270
5295
    int i;
5271
5296
 
5272
 
    if ((avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE)
 
5297
    if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
5273
5298
        && v->sprite_output_frame.data[0])
5274
5299
        avctx->release_buffer(avctx, &v->sprite_output_frame);
5275
5300
    for (i = 0; i < 4; i++)
5276
5301
        av_freep(&v->sr_rows[i >> 1][i & 1]);
5277
5302
    av_freep(&v->hrd_rate);
5278
5303
    av_freep(&v->hrd_buffer);
5279
 
    MPV_common_end(&v->s);
 
5304
    ff_MPV_common_end(&v->s);
5280
5305
    av_freep(&v->mv_type_mb_plane);
5281
5306
    av_freep(&v->direct_mb_plane);
5282
5307
    av_freep(&v->forward_mb_plane);
5302
5327
 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5303
5328
 */
5304
5329
static int vc1_decode_frame(AVCodecContext *avctx, void *data,
5305
 
                            int *data_size, AVPacket *avpkt)
 
5330
                            int *got_frame, AVPacket *avpkt)
5306
5331
{
5307
5332
    const uint8_t *buf = avpkt->data;
5308
5333
    int buf_size = avpkt->size, n_slices = 0, i;
5322
5347
    if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
5323
5348
        /* special case for last picture */
5324
5349
        if (s->low_delay == 0 && s->next_picture_ptr) {
5325
 
            *pict = *(AVFrame*)s->next_picture_ptr;
 
5350
            *pict = s->next_picture_ptr->f;
5326
5351
            s->next_picture_ptr = NULL;
5327
5352
 
5328
 
            *data_size = sizeof(AVFrame);
 
5353
            *got_frame = 1;
5329
5354
        }
5330
5355
 
5331
5356
        return 0;
5333
5358
 
5334
5359
    if (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
5335
5360
        if (v->profile < PROFILE_ADVANCED)
5336
 
            avctx->pix_fmt = PIX_FMT_VDPAU_WMV3;
 
5361
            avctx->pix_fmt = AV_PIX_FMT_VDPAU_WMV3;
5337
5362
        else
5338
 
            avctx->pix_fmt = PIX_FMT_VDPAU_VC1;
 
5363
            avctx->pix_fmt = AV_PIX_FMT_VDPAU_VC1;
5339
5364
    }
5340
5365
 
5341
5366
    //for advanced profile we may need to parse and unescape data
5342
 
    if (avctx->codec_id == CODEC_ID_VC1 || avctx->codec_id == CODEC_ID_VC1IMAGE) {
 
5367
    if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5343
5368
        int buf_size2 = 0;
5344
5369
        buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5345
5370
 
5361
5386
                    break;
5362
5387
                case VC1_CODE_FIELD: {
5363
5388
                    int buf_size3;
5364
 
                    slices = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5365
 
                    if (!slices)
 
5389
                    tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
 
5390
                    if (!tmp)
5366
5391
                        goto err;
 
5392
                    slices = tmp;
5367
5393
                    slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5368
5394
                    if (!slices[n_slices].buf)
5369
5395
                        goto err;
5381
5407
                case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
5382
5408
                    buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5383
5409
                    init_get_bits(&s->gb, buf2, buf_size2 * 8);
5384
 
                    vc1_decode_entry_point(avctx, v, &s->gb);
 
5410
                    ff_vc1_decode_entry_point(avctx, v, &s->gb);
5385
5411
                    break;
5386
5412
                case VC1_CODE_SLICE: {
5387
5413
                    int buf_size3;
5388
 
                    slices = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5389
 
                    if (!slices)
 
5414
                    tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
 
5415
                    if (!tmp)
5390
5416
                        goto err;
 
5417
                    slices = tmp;
5391
5418
                    slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5392
5419
                    if (!slices[n_slices].buf)
5393
5420
                        goto err;
5435
5462
    if (v->res_sprite) {
5436
5463
        v->new_sprite  = !get_bits1(&s->gb);
5437
5464
        v->two_sprites =  get_bits1(&s->gb);
5438
 
        /* res_sprite means a Windows Media Image stream, CODEC_ID_*IMAGE means
 
5465
        /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
5439
5466
           we're using the sprite compositor. These are intentionally kept separate
5440
5467
           so you can get the raw sprites by using the wmv3 decoder for WMVP or
5441
5468
           the vc1 one for WVP2 */
5442
 
        if (avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE) {
 
5469
        if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5443
5470
            if (v->new_sprite) {
5444
5471
                // switch AVCodecContext parameters to those of the sprites
5445
5472
                avctx->width  = avctx->coded_width  = v->sprite_width;
5453
5480
    if (s->context_initialized &&
5454
5481
        (s->width  != avctx->coded_width ||
5455
5482
         s->height != avctx->coded_height)) {
5456
 
        vc1_decode_end(avctx);
 
5483
        ff_vc1_decode_end(avctx);
5457
5484
    }
5458
5485
 
5459
5486
    if (!s->context_initialized) {
5460
 
        if (ff_msmpeg4_decode_init(avctx) < 0 || vc1_decode_init_alloc_tables(v) < 0)
5461
 
            return -1;
 
5487
        if (ff_msmpeg4_decode_init(avctx) < 0 || ff_vc1_decode_init_alloc_tables(v) < 0)
 
5488
            goto err;
5462
5489
 
5463
5490
        s->low_delay = !avctx->has_b_frames || v->res_sprite;
5464
5491
 
5480
5507
    // do parse frame header
5481
5508
    v->pic_header_flag = 0;
5482
5509
    if (v->profile < PROFILE_ADVANCED) {
5483
 
        if (vc1_parse_frame_header(v, &s->gb) == -1) {
 
5510
        if (ff_vc1_parse_frame_header(v, &s->gb) == -1) {
5484
5511
            goto err;
5485
5512
        }
5486
5513
    } else {
5487
 
        if (vc1_parse_frame_header_adv(v, &s->gb) == -1) {
 
5514
        if (ff_vc1_parse_frame_header_adv(v, &s->gb) == -1) {
5488
5515
            goto err;
5489
5516
        }
5490
5517
    }
5491
5518
 
5492
 
    if ((avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE)
 
5519
    if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
5493
5520
        && s->pict_type != AV_PICTURE_TYPE_I) {
5494
5521
        av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
5495
5522
        goto err;
5512
5539
    s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
5513
5540
 
5514
5541
    /* skip B-frames if we don't have reference frames */
5515
 
    if (s->last_picture_ptr == NULL && (s->pict_type == AV_PICTURE_TYPE_B || s->dropable)) {
 
5542
    if (s->last_picture_ptr == NULL && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
5516
5543
        goto err;
5517
5544
    }
5518
5545
    if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
5528
5555
            s->next_p_frame_damaged = 0;
5529
5556
    }
5530
5557
 
5531
 
    if (MPV_frame_start(s, avctx) < 0) {
 
5558
    if (ff_MPV_frame_start(s, avctx) < 0) {
5532
5559
        goto err;
5533
5560
    }
5534
5561
 
5549
5576
        ff_er_frame_start(s);
5550
5577
 
5551
5578
        v->bits = buf_size * 8;
 
5579
        v->end_mb_x = s->mb_width;
5552
5580
        if (v->field_mode) {
5553
5581
            uint8_t *tmp[2];
5554
5582
            s->current_picture.f.linesize[0] <<= 1;
5566
5594
            v->mv_f[1] = tmp[1];
5567
5595
        }
5568
5596
        mb_height = s->mb_height >> v->field_mode;
 
5597
 
 
5598
        if (!mb_height) {
 
5599
            av_log(v->s.avctx, AV_LOG_ERROR, "Invalid mb_height.\n");
 
5600
            goto err;
 
5601
        }
 
5602
 
5569
5603
        for (i = 0; i <= n_slices; i++) {
5570
5604
            if (i > 0 &&  slices[i - 1].mby_start >= mb_height) {
5571
5605
                if (v->field_mode <= 0) {
5584
5618
            }
5585
5619
            if (i) {
5586
5620
                v->pic_header_flag = 0;
5587
 
                if (v->field_mode && i == n_slices1 + 2)
5588
 
                    vc1_parse_frame_header_adv(v, &s->gb);
5589
 
                else if (get_bits1(&s->gb)) {
 
5621
                if (v->field_mode && i == n_slices1 + 2) {
 
5622
                    if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
 
5623
                        av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
 
5624
                        continue;
 
5625
                    }
 
5626
                } else if (get_bits1(&s->gb)) {
5590
5627
                    v->pic_header_flag = 1;
5591
 
                    vc1_parse_frame_header_adv(v, &s->gb);
 
5628
                    if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
 
5629
                        av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
 
5630
                        continue;
 
5631
                    }
5592
5632
                }
5593
5633
            }
5594
5634
            s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
5596
5636
                s->end_mb_y = (i == n_slices     ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
5597
5637
            else
5598
5638
                s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
5599
 
            vc1_decode_blocks(v);
 
5639
            ff_vc1_decode_blocks(v);
5600
5640
            if (i != n_slices)
5601
5641
                s->gb = slices[i].gb;
5602
5642
        }
5612
5652
            s->linesize                      >>= 1;
5613
5653
            s->uvlinesize                    >>= 1;
5614
5654
        }
5615
 
//av_log(s->avctx, AV_LOG_INFO, "Consumed %i/%i bits\n", get_bits_count(&s->gb), s->gb.size_in_bits);
 
5655
        av_dlog(s->avctx, "Consumed %i/%i bits\n",
 
5656
                get_bits_count(&s->gb), s->gb.size_in_bits);
5616
5657
//  if (get_bits_count(&s->gb) > buf_size * 8)
5617
5658
//      return -1;
5618
5659
        ff_er_frame_end(s);
5619
5660
    }
5620
5661
 
5621
 
    MPV_frame_end(s);
 
5662
    ff_MPV_frame_end(s);
5622
5663
 
5623
 
    if (avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE) {
 
5664
    if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5624
5665
image:
5625
5666
        avctx->width  = avctx->coded_width  = v->output_width;
5626
5667
        avctx->height = avctx->coded_height = v->output_height;
5631
5672
            goto err;
5632
5673
#endif
5633
5674
        *pict      = v->sprite_output_frame;
5634
 
        *data_size = sizeof(AVFrame);
 
5675
        *got_frame = 1;
5635
5676
    } else {
5636
5677
        if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
5637
 
            *pict = *(AVFrame*)s->current_picture_ptr;
 
5678
            *pict = s->current_picture_ptr->f;
5638
5679
        } else if (s->last_picture_ptr != NULL) {
5639
 
            *pict = *(AVFrame*)s->last_picture_ptr;
 
5680
            *pict = s->last_picture_ptr->f;
5640
5681
        }
5641
5682
        if (s->last_picture_ptr || s->low_delay) {
5642
 
            *data_size = sizeof(AVFrame);
 
5683
            *got_frame = 1;
5643
5684
            ff_print_debug_info(s, pict);
5644
5685
        }
5645
5686
    }
5671
5712
AVCodec ff_vc1_decoder = {
5672
5713
    .name           = "vc1",
5673
5714
    .type           = AVMEDIA_TYPE_VIDEO,
5674
 
    .id             = CODEC_ID_VC1,
 
5715
    .id             = AV_CODEC_ID_VC1,
5675
5716
    .priv_data_size = sizeof(VC1Context),
5676
5717
    .init           = vc1_decode_init,
5677
 
    .close          = vc1_decode_end,
 
5718
    .close          = ff_vc1_decode_end,
5678
5719
    .decode         = vc1_decode_frame,
5679
5720
    .flush          = ff_mpeg_flush,
5680
5721
    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
5687
5728
AVCodec ff_wmv3_decoder = {
5688
5729
    .name           = "wmv3",
5689
5730
    .type           = AVMEDIA_TYPE_VIDEO,
5690
 
    .id             = CODEC_ID_WMV3,
 
5731
    .id             = AV_CODEC_ID_WMV3,
5691
5732
    .priv_data_size = sizeof(VC1Context),
5692
5733
    .init           = vc1_decode_init,
5693
 
    .close          = vc1_decode_end,
 
5734
    .close          = ff_vc1_decode_end,
5694
5735
    .decode         = vc1_decode_frame,
5695
5736
    .flush          = ff_mpeg_flush,
5696
5737
    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
5704
5745
AVCodec ff_wmv3_vdpau_decoder = {
5705
5746
    .name           = "wmv3_vdpau",
5706
5747
    .type           = AVMEDIA_TYPE_VIDEO,
5707
 
    .id             = CODEC_ID_WMV3,
 
5748
    .id             = AV_CODEC_ID_WMV3,
5708
5749
    .priv_data_size = sizeof(VC1Context),
5709
5750
    .init           = vc1_decode_init,
5710
 
    .close          = vc1_decode_end,
 
5751
    .close          = ff_vc1_decode_end,
5711
5752
    .decode         = vc1_decode_frame,
5712
5753
    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
5713
5754
    .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
5714
 
    .pix_fmts       = (const enum PixelFormat[]){PIX_FMT_VDPAU_WMV3, PIX_FMT_NONE},
 
5755
    .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_WMV3, AV_PIX_FMT_NONE },
5715
5756
    .profiles       = NULL_IF_CONFIG_SMALL(profiles)
5716
5757
};
5717
5758
#endif
5720
5761
AVCodec ff_vc1_vdpau_decoder = {
5721
5762
    .name           = "vc1_vdpau",
5722
5763
    .type           = AVMEDIA_TYPE_VIDEO,
5723
 
    .id             = CODEC_ID_VC1,
 
5764
    .id             = AV_CODEC_ID_VC1,
5724
5765
    .priv_data_size = sizeof(VC1Context),
5725
5766
    .init           = vc1_decode_init,
5726
 
    .close          = vc1_decode_end,
 
5767
    .close          = ff_vc1_decode_end,
5727
5768
    .decode         = vc1_decode_frame,
5728
5769
    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
5729
5770
    .long_name      = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
5730
 
    .pix_fmts       = (const enum PixelFormat[]){PIX_FMT_VDPAU_VC1, PIX_FMT_NONE},
 
5771
    .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_VC1, AV_PIX_FMT_NONE },
5731
5772
    .profiles       = NULL_IF_CONFIG_SMALL(profiles)
5732
5773
};
5733
5774
#endif
5736
5777
AVCodec ff_wmv3image_decoder = {
5737
5778
    .name           = "wmv3image",
5738
5779
    .type           = AVMEDIA_TYPE_VIDEO,
5739
 
    .id             = CODEC_ID_WMV3IMAGE,
 
5780
    .id             = AV_CODEC_ID_WMV3IMAGE,
5740
5781
    .priv_data_size = sizeof(VC1Context),
5741
5782
    .init           = vc1_decode_init,
5742
 
    .close          = vc1_decode_end,
 
5783
    .close          = ff_vc1_decode_end,
5743
5784
    .decode         = vc1_decode_frame,
5744
5785
    .capabilities   = CODEC_CAP_DR1,
5745
5786
    .flush          = vc1_sprite_flush,
5752
5793
AVCodec ff_vc1image_decoder = {
5753
5794
    .name           = "vc1image",
5754
5795
    .type           = AVMEDIA_TYPE_VIDEO,
5755
 
    .id             = CODEC_ID_VC1IMAGE,
 
5796
    .id             = AV_CODEC_ID_VC1IMAGE,
5756
5797
    .priv_data_size = sizeof(VC1Context),
5757
5798
    .init           = vc1_decode_init,
5758
 
    .close          = vc1_decode_end,
 
5799
    .close          = ff_vc1_decode_end,
5759
5800
    .decode         = vc1_decode_frame,
5760
5801
    .capabilities   = CODEC_CAP_DR1,
5761
5802
    .flush          = vc1_sprite_flush,