← Back to branch summary

~ubuntu-branches/ubuntu/saucy/gst-libav1.0/saucy-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-07-30 09:00:15 UTC
  • mfrom: (1.1.16) (7.1.7 experimental)
  • Revision ID: package-import@ubuntu.com-20130730090015-sc1ou2yssu7q5w4e
Tags: 1.1.3-1
* New upstream development snapshot:
  + debian/control:
    - Build depend on GStreamer and gst-plugins-base >= 1.1.3.

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
 
431
430
    if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
432
431
        || s->h_edge_pos < 22 || v_edge_pos < 22
433
432
        || (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) {
 
433
        || (unsigned)(src_y - 1)        > v_edge_pos    - (my&3) - 16 - 3) {
435
434
        uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
436
435
 
437
436
        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);
 
437
        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
 
438
                                 17 + s->mspel * 2, 17 + s->mspel * 2,
 
439
                                 src_x - s->mspel, src_y - s->mspel,
 
440
                                 s->h_edge_pos, v_edge_pos);
442
441
        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);
 
442
        s->vdsp.emulated_edge_mc(uvbuf     , srcU, s->uvlinesize, 8 + 1, 8 + 1,
 
443
                                 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
 
444
        s->vdsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
 
445
                                 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
447
446
        srcU = uvbuf;
448
447
        srcV = uvbuf + 16;
449
448
        /* if we deal with range reduction we need to scale source blocks */
668
667
        || (unsigned)(src_y - (s->mspel << fieldmv)) > v_edge_pos - (my & 3) - ((8 + s->mspel * 2) << fieldmv)) {
669
668
        srcY -= s->mspel * (1 + (s->linesize << fieldmv));
670
669
        /* 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);
 
670
        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
 
671
                                 9 + s->mspel * 2, (9 + s->mspel * 2) << fieldmv,
 
672
                                 src_x - s->mspel, src_y - (s->mspel << fieldmv),
 
673
                                 s->h_edge_pos, v_edge_pos);
675
674
        srcY = s->edge_emu_buffer;
676
675
        /* if we deal with range reduction we need to scale source blocks */
677
676
        if (v->rangeredfrm) {
795
794
    /* calculate chroma MV vector from four luma MVs */
796
795
    if (!v->field_mode || (v->field_mode && !v->numref)) {
797
796
        valid_count = get_chroma_mv(mvx, mvy, intra, 0, &tx, &ty);
 
797
        chroma_ref_type = v->reffield;
798
798
        if (!valid_count) {
799
799
            s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0;
800
800
            s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0;
868
868
        || s->h_edge_pos < 18 || v_edge_pos < 18
869
869
        || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 9
870
870
        || (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);
 
871
        s->vdsp.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->vdsp.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);
877
877
        srcU = s->edge_emu_buffer;
878
878
        srcV = s->edge_emu_buffer + 16;
879
879
 
973
973
            || s->h_edge_pos < 10 || v_edge_pos < (5 << fieldmv)
974
974
            || (unsigned)uvsrc_x > (s->h_edge_pos >> 1) - 5
975
975
            || (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);
 
976
            s->vdsp.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->vdsp.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);
982
982
            srcU = s->edge_emu_buffer;
983
983
            srcV = s->edge_emu_buffer + 16;
984
984
 
1048
1048
            mquant = v->altpq;                                 \
1049
1049
        if ((edges&8) && s->mb_y == (s->mb_height - 1))        \
1050
1050
            mquant = v->altpq;                                 \
 
1051
        if (!mquant || mquant > 31) {                          \
 
1052
            av_log(v->s.avctx, AV_LOG_ERROR,                   \
 
1053
                   "Overriding invalid mquant %d\n", mquant);  \
 
1054
            mquant = 1;                                        \
 
1055
        }                                                      \
1051
1056
    }
1052
1057
 
1053
1058
/**
1128
1133
        *dmv_x = get_bits(gb, v->k_x);
1129
1134
        *dmv_y = get_bits(gb, v->k_y);
1130
1135
        if (v->numref) {
1131
 
            *pred_flag = *dmv_y & 1;
1132
 
            *dmv_y     = (*dmv_y + *pred_flag) >> 1;
 
1136
            if (pred_flag) {
 
1137
                *pred_flag = *dmv_y & 1;
 
1138
                *dmv_y     = (*dmv_y + *pred_flag) >> 1;
 
1139
            } else {
 
1140
                *dmv_y     = (*dmv_y + (*dmv_y & 1)) >> 1;
 
1141
            }
1133
1142
        }
1134
1143
    }
1135
1144
    else {
1155
1164
            *dmv_y = (sign ^ ((val >> 1) + offs_tab[index1 >> v->numref])) - sign;
1156
1165
        } else
1157
1166
            *dmv_y = 0;
1158
 
        if (v->numref)
 
1167
        if (v->numref && pred_flag)
1159
1168
            *pred_flag = index1 & 1;
1160
1169
    }
1161
1170
}
1173
1182
        refdist = dir ? v->brfd : v->frfd;
1174
1183
    if (refdist > 3)
1175
1184
        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];
 
1185
    scalesame1    = ff_vc1_field_mvpred_scales[table_index][1][refdist];
 
1186
    scalesame2    = ff_vc1_field_mvpred_scales[table_index][2][refdist];
 
1187
    scalezone1_x  = ff_vc1_field_mvpred_scales[table_index][3][refdist];
 
1188
    zone1offset_x = ff_vc1_field_mvpred_scales[table_index][5][refdist];
1180
1189
 
1181
1190
    if (FFABS(n) > 255)
1182
1191
        scaledvalue = n;
1206
1215
        refdist = dir ? v->brfd : v->frfd;
1207
1216
    if (refdist > 3)
1208
1217
        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];
 
1218
    scalesame1    = ff_vc1_field_mvpred_scales[table_index][1][refdist];
 
1219
    scalesame2    = ff_vc1_field_mvpred_scales[table_index][2][refdist];
 
1220
    scalezone1_y  = ff_vc1_field_mvpred_scales[table_index][4][refdist];
 
1221
    zone1offset_y = ff_vc1_field_mvpred_scales[table_index][6][refdist];
1213
1222
 
1214
1223
    if (FFABS(n) > 63)
1215
1224
        scaledvalue = n;
1237
1246
    int scaledvalue;
1238
1247
 
1239
1248
    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];
 
1249
    scalezone1_x  = ff_vc1_b_field_mvpred_scales[3][brfd];
 
1250
    zone1offset_x = ff_vc1_b_field_mvpred_scales[5][brfd];
 
1251
    scaleopp1     = ff_vc1_b_field_mvpred_scales[1][brfd];
 
1252
    scaleopp2     = ff_vc1_b_field_mvpred_scales[2][brfd];
1244
1253
 
1245
1254
    if (FFABS(n) > 255)
1246
1255
        scaledvalue = n;
1264
1273
    int scaledvalue;
1265
1274
 
1266
1275
    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];
 
1276
    scalezone1_y  = ff_vc1_b_field_mvpred_scales[4][brfd];
 
1277
    zone1offset_y = ff_vc1_b_field_mvpred_scales[6][brfd];
 
1278
    scaleopp1     = ff_vc1_b_field_mvpred_scales[1][brfd];
 
1279
    scaleopp2     = ff_vc1_b_field_mvpred_scales[2][brfd];
1271
1280
 
1272
1281
    if (FFABS(n) > 63)
1273
1282
        scaledvalue = n;
1303
1312
        return n;
1304
1313
    }
1305
1314
    brfd      = FFMIN(v->brfd, 3);
1306
 
    scalesame = vc1_b_field_mvpred_scales[0][brfd];
 
1315
    scalesame = ff_vc1_b_field_mvpred_scales[0][brfd];
1307
1316
 
1308
1317
    n = (n * scalesame >> 8) << hpel;
1309
1318
    return n;
1327
1336
        refdist = FFMIN(v->refdist, 3);
1328
1337
    else
1329
1338
        refdist = dir ? v->brfd : v->frfd;
1330
 
    scaleopp = vc1_field_mvpred_scales[dir ^ v->second_field][0][refdist];
 
1339
    scaleopp = ff_vc1_field_mvpred_scales[dir ^ v->second_field][0][refdist];
1331
1340
 
1332
1341
    n = (n * scaleopp >> 8) << hpel;
1333
1342
    return n;
1345
1354
    int px, py;
1346
1355
    int sum;
1347
1356
    int mixedmv_pic, num_samefield = 0, num_oppfield = 0;
1348
 
    int opposit, a_f, b_f, c_f;
 
1357
    int opposite, a_f, b_f, c_f;
1349
1358
    int16_t field_predA[2];
1350
1359
    int16_t field_predB[2];
1351
1360
    int16_t field_predC[2];
1453
1462
    }
1454
1463
 
1455
1464
    if (v->field_mode) {
1456
 
        if (num_samefield <= num_oppfield)
1457
 
            opposit = 1 - pred_flag;
1458
 
        else
1459
 
            opposit = pred_flag;
 
1465
        if (!v->numref)
 
1466
            // REFFIELD determines if the last field or the second-last field is
 
1467
            // to be used as reference
 
1468
            opposite = 1 - v->reffield;
 
1469
        else {
 
1470
            if (num_samefield <= num_oppfield)
 
1471
                opposite = 1 - pred_flag;
 
1472
            else
 
1473
                opposite = pred_flag;
 
1474
        }
1460
1475
    } else
1461
 
        opposit = 0;
1462
 
    if (opposit) {
 
1476
        opposite = 0;
 
1477
    if (opposite) {
1463
1478
        if (a_valid && !a_f) {
1464
1479
            field_predA[0] = scaleforopp(v, field_predA[0], 0, dir);
1465
1480
            field_predA[1] = scaleforopp(v, field_predA[1], 1, dir);
1562
1577
        }
1563
1578
    }
1564
1579
 
1565
 
    if (v->field_mode && !s->quarter_sample) {
1566
 
        r_x <<= 1;
1567
 
        r_y <<= 1;
1568
 
    }
1569
1580
    if (v->field_mode && v->numref)
1570
1581
        r_y >>= 1;
1571
1582
    if (v->field_mode && v->cur_field_type && v->ref_field_type[dir] == 0)
1876
1887
    }
1877
1888
 
1878
1889
    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) {
 
1890
        || (unsigned)(src_x - 1) > s->h_edge_pos - (mx & 3) - 16 - 3
 
1891
        || (unsigned)(src_y - 1) > v_edge_pos    - (my & 3) - 16 - 3) {
1881
1892
        uint8_t *uvbuf = s->edge_emu_buffer + 19 * s->linesize;
1882
1893
 
1883
1894
        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);
 
1895
        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
 
1896
                                 17 + s->mspel * 2, 17 + s->mspel * 2,
 
1897
                                 src_x - s->mspel, src_y - s->mspel,
 
1898
                                 s->h_edge_pos, v_edge_pos);
1888
1899
        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);
 
1900
        s->vdsp.emulated_edge_mc(uvbuf     , srcU, s->uvlinesize, 8 + 1, 8 + 1,
 
1901
                                 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
 
1902
        s->vdsp.emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, 8 + 1, 8 + 1,
 
1903
                                 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, v_edge_pos >> 1);
1893
1904
        srcU = uvbuf;
1894
1905
        srcV = uvbuf + 16;
1895
1906
        /* if we deal with range reduction we need to scale source blocks */
1973
1984
#endif
1974
1985
}
1975
1986
 
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
1987
/** Reconstruct motion vector for B-frame and do motion compensation
1991
1988
 */
1992
1989
static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2],
2240
2237
    if (v->bmvtype == BMV_TYPE_DIRECT) {
2241
2238
        int total_opp, k, f;
2242
2239
        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);
 
2240
            s->mv[0][0][0] = scale_mv(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0],
 
2241
                                      v->bfraction, 0, s->quarter_sample);
 
2242
            s->mv[0][0][1] = scale_mv(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1],
 
2243
                                      v->bfraction, 0, s->quarter_sample);
 
2244
            s->mv[1][0][0] = scale_mv(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0],
 
2245
                                      v->bfraction, 1, s->quarter_sample);
 
2246
            s->mv[1][0][1] = scale_mv(s->next_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1],
 
2247
                                      v->bfraction, 1, s->quarter_sample);
2251
2248
 
2252
2249
            total_opp = v->mv_f_next[0][s->block_index[0] + v->blocks_off]
2253
2250
                      + v->mv_f_next[0][s->block_index[1] + v->blocks_off]
3835
3832
                vc1_mc_4mv_chroma4(v);
3836
3833
            } else {
3837
3834
                mvbp = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][2];
 
3835
                dmv_x = dmv_y = 0;
3838
3836
                if (mvbp) {
3839
3837
                    get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0);
3840
3838
                }
3949
3947
        s->current_picture.f.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16;
3950
3948
        for (i = 0; i < 6; i++) v->mb_type[0][s->block_index[i]] = 0;
3951
3949
        if (idx_mbmode <= 5) { // 1-MV
3952
 
            dmv_x = dmv_y = 0;
 
3950
            dmv_x = dmv_y = pred_flag = 0;
3953
3951
            if (idx_mbmode & 1) {
3954
3952
                get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag);
3955
3953
            }
4357
4355
    s->mb_x = s->mb_y = 0;
4358
4356
    s->mb_intra         = 1;
4359
4357
    s->first_slice_line = 1;
4360
 
    for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
 
4358
    for (s->mb_y = 0; s->mb_y < s->end_mb_y; s->mb_y++) {
4361
4359
        s->mb_x = 0;
4362
4360
        ff_init_block_index(s);
4363
 
        for (; s->mb_x < s->mb_width; s->mb_x++) {
 
4361
        for (; s->mb_x < v->end_mb_x; s->mb_x++) {
4364
4362
            uint8_t *dst[6];
4365
4363
            ff_update_block_index(s);
4366
4364
            dst[0] = s->dest[0];
4447
4445
        s->first_slice_line = 0;
4448
4446
    }
4449
4447
    if (v->s.loop_filter)
4450
 
        ff_draw_horiz_band(s, (s->mb_height - 1) * 16, 16);
 
4448
        ff_draw_horiz_band(s, (s->end_mb_y - 1) * 16, 16);
 
4449
 
 
4450
    /* This is intentionally mb_height and not end_mb_y - unlike in advanced
 
4451
     * profile, these only differ are when decoding MSS2 rectangles. */
4451
4452
    ff_er_add_slice(s, 0, 0, s->mb_width - 1, s->mb_height - 1, ER_MB_END);
4452
4453
}
4453
4454
 
4741
4742
    s->pict_type = AV_PICTURE_TYPE_P;
4742
4743
}
4743
4744
 
4744
 
static void vc1_decode_blocks(VC1Context *v)
 
4745
void ff_vc1_decode_blocks(VC1Context *v)
4745
4746
{
4746
4747
 
4747
4748
    v->s.esc3_level_length = 0;
4899
4900
        av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
4900
4901
 
4901
4902
    if (get_bits_count(gb) >= gb->size_in_bits +
4902
 
       (avctx->codec_id == CODEC_ID_WMV3IMAGE ? 64 : 0))
 
4903
       (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0))
4903
4904
        av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
4904
4905
    if (get_bits_count(gb) < gb->size_in_bits - 8)
4905
4906
        av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
4937
4938
                int      iline  = s->current_picture.f.linesize[plane];
4938
4939
                int      ycoord = yoff[sprite] + yadv[sprite] * row;
4939
4940
                int      yline  = ycoord >> 16;
 
4941
                int      next_line;
4940
4942
                ysub[sprite] = ycoord & 0xFFFF;
4941
4943
                if (sprite) {
4942
4944
                    iplane = s->last_picture.f.data[plane];
4943
4945
                    iline  = s->last_picture.f.linesize[plane];
4944
4946
                }
 
4947
                next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
4945
4948
                if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
4946
4949
                        src_h[sprite][0] = iplane + (xoff[sprite] >> 16) +  yline      * iline;
4947
4950
                    if (ysub[sprite])
4948
 
                        src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + (yline + 1) * iline;
 
4951
                        src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
4949
4952
                } else {
4950
4953
                    if (sr_cache[sprite][0] != yline) {
4951
4954
                        if (sr_cache[sprite][1] == yline) {
4957
4960
                        }
4958
4961
                    }
4959
4962
                    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);
 
4963
                        v->vc1dsp.sprite_h(v->sr_rows[sprite][1],
 
4964
                                           iplane + next_line, xoff[sprite],
 
4965
                                           xadv[sprite], width);
4961
4966
                        sr_cache[sprite][1] = yline + 1;
4962
4967
                    }
4963
4968
                    src_h[sprite][0] = v->sr_rows[sprite][0];
5021
5026
 
5022
5027
    v->sprite_output_frame.buffer_hints = FF_BUFFER_HINTS_VALID;
5023
5028
    v->sprite_output_frame.reference = 0;
5024
 
    if (avctx->get_buffer(avctx, &v->sprite_output_frame) < 0) {
 
5029
    if (ff_get_buffer(avctx, &v->sprite_output_frame) < 0) {
5025
5030
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
5026
5031
        return -1;
5027
5032
    }
5051
5056
 
5052
5057
#endif
5053
5058
 
5054
 
static av_cold int vc1_decode_init_alloc_tables(VC1Context *v)
 
5059
av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
5055
5060
{
5056
5061
    MpegEncContext *s = &v->s;
5057
5062
    int i;
5104
5109
 
5105
5110
    ff_intrax8_common_init(&v->x8,s);
5106
5111
 
5107
 
    if (s->avctx->codec_id == CODEC_ID_WMV3IMAGE || s->avctx->codec_id == CODEC_ID_VC1IMAGE) {
 
5112
    if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5108
5113
        for (i = 0; i < 4; i++)
5109
5114
            if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width))) return -1;
5110
5115
    }
5117
5122
    return 0;
5118
5123
}
5119
5124
 
 
5125
av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
 
5126
{
 
5127
    int i;
 
5128
    for (i = 0; i < 64; i++) {
 
5129
#define transpose(x) ((x >> 3) | ((x & 7) << 3))
 
5130
        v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
 
5131
        v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
 
5132
        v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
 
5133
        v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
 
5134
        v->zzi_8x8[i]   = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
 
5135
    }
 
5136
    v->left_blk_sh = 0;
 
5137
    v->top_blk_sh  = 3;
 
5138
}
 
5139
 
5120
5140
/** Initialize a VC1/WMV3 decoder
5121
5141
 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5122
5142
 * @todo TODO: Decypher remaining bits in extra_data
5126
5146
    VC1Context *v = avctx->priv_data;
5127
5147
    MpegEncContext *s = &v->s;
5128
5148
    GetBitContext gb;
5129
 
    int i;
5130
5149
 
5131
5150
    /* save the container output size for WMImage */
5132
5151
    v->output_width  = avctx->width;
5137
5156
    if (!(avctx->flags & CODEC_FLAG_GRAY))
5138
5157
        avctx->pix_fmt = avctx->get_format(avctx, avctx->codec->pix_fmts);
5139
5158
    else
5140
 
        avctx->pix_fmt = PIX_FMT_GRAY8;
 
5159
        avctx->pix_fmt = AV_PIX_FMT_GRAY8;
5141
5160
    avctx->hwaccel = ff_find_hwaccel(avctx->codec->id, avctx->pix_fmt);
5142
5161
    v->s.avctx = avctx;
5143
5162
    avctx->flags |= CODEC_FLAG_EMU_EDGE;
5151
5170
        return -1;
5152
5171
    ff_vc1dsp_init(&v->vc1dsp);
5153
5172
 
5154
 
    if (avctx->codec_id == CODEC_ID_WMV3 || avctx->codec_id == CODEC_ID_WMV3IMAGE) {
 
5173
    if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
5155
5174
        int count = 0;
5156
5175
 
5157
5176
        // looks like WMV3 has a sequence header stored in the extradata
5161
5180
 
5162
5181
        init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
5163
5182
 
5164
 
        if (vc1_decode_sequence_header(avctx, v, &gb) < 0)
 
5183
        if (ff_vc1_decode_sequence_header(avctx, v, &gb) < 0)
5165
5184
          return -1;
5166
5185
 
5167
5186
        count = avctx->extradata_size*8 - get_bits_count(&gb);
5196
5215
            init_get_bits(&gb, buf2, buf2_size * 8);
5197
5216
            switch (AV_RB32(start)) {
5198
5217
            case VC1_CODE_SEQHDR:
5199
 
                if (vc1_decode_sequence_header(avctx, v, &gb) < 0) {
 
5218
                if (ff_vc1_decode_sequence_header(avctx, v, &gb) < 0) {
5200
5219
                    av_free(buf2);
5201
5220
                    return -1;
5202
5221
                }
5203
5222
                seq_initialized = 1;
5204
5223
                break;
5205
5224
            case VC1_CODE_ENTRYPOINT:
5206
 
                if (vc1_decode_entry_point(avctx, v, &gb) < 0) {
 
5225
                if (ff_vc1_decode_entry_point(avctx, v, &gb) < 0) {
5207
5226
                    av_free(buf2);
5208
5227
                    return -1;
5209
5228
                }
5229
5248
    s->mb_height = (avctx->coded_height + 15) >> 4;
5230
5249
 
5231
5250
    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;
 
5251
        ff_vc1_init_transposed_scantables(v);
5242
5252
    } else {
5243
 
        memcpy(v->zz_8x8, wmv1_scantable, 4*64);
 
5253
        memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
5244
5254
        v->left_blk_sh = 3;
5245
5255
        v->top_blk_sh  = 0;
5246
5256
    }
5247
5257
 
5248
 
    if (avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE) {
 
5258
    if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5249
5259
        v->sprite_width  = avctx->coded_width;
5250
5260
        v->sprite_height = avctx->coded_height;
5251
5261
 
5264
5274
/** Close a VC1/WMV3 decoder
5265
5275
 * @warning Initial try at using MpegEncContext stuff
5266
5276
 */
5267
 
static av_cold int vc1_decode_end(AVCodecContext *avctx)
 
5277
av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
5268
5278
{
5269
5279
    VC1Context *v = avctx->priv_data;
5270
5280
    int i;
5271
5281
 
5272
 
    if ((avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE)
 
5282
    if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
5273
5283
        && v->sprite_output_frame.data[0])
5274
5284
        avctx->release_buffer(avctx, &v->sprite_output_frame);
5275
5285
    for (i = 0; i < 4; i++)
5276
5286
        av_freep(&v->sr_rows[i >> 1][i & 1]);
5277
5287
    av_freep(&v->hrd_rate);
5278
5288
    av_freep(&v->hrd_buffer);
5279
 
    MPV_common_end(&v->s);
 
5289
    ff_MPV_common_end(&v->s);
5280
5290
    av_freep(&v->mv_type_mb_plane);
5281
5291
    av_freep(&v->direct_mb_plane);
5282
5292
    av_freep(&v->forward_mb_plane);
5302
5312
 * @todo TODO: Handle VC-1 IDUs (Transport level?)
5303
5313
 */
5304
5314
static int vc1_decode_frame(AVCodecContext *avctx, void *data,
5305
 
                            int *data_size, AVPacket *avpkt)
 
5315
                            int *got_frame, AVPacket *avpkt)
5306
5316
{
5307
5317
    const uint8_t *buf = avpkt->data;
5308
5318
    int buf_size = avpkt->size, n_slices = 0, i;
5322
5332
    if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
5323
5333
        /* special case for last picture */
5324
5334
        if (s->low_delay == 0 && s->next_picture_ptr) {
5325
 
            *pict = *(AVFrame*)s->next_picture_ptr;
 
5335
            *pict = s->next_picture_ptr->f;
5326
5336
            s->next_picture_ptr = NULL;
5327
5337
 
5328
 
            *data_size = sizeof(AVFrame);
 
5338
            *got_frame = 1;
5329
5339
        }
5330
5340
 
5331
5341
        return 0;
5333
5343
 
5334
5344
    if (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) {
5335
5345
        if (v->profile < PROFILE_ADVANCED)
5336
 
            avctx->pix_fmt = PIX_FMT_VDPAU_WMV3;
 
5346
            avctx->pix_fmt = AV_PIX_FMT_VDPAU_WMV3;
5337
5347
        else
5338
 
            avctx->pix_fmt = PIX_FMT_VDPAU_VC1;
 
5348
            avctx->pix_fmt = AV_PIX_FMT_VDPAU_VC1;
5339
5349
    }
5340
5350
 
5341
5351
    //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) {
 
5352
    if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5343
5353
        int buf_size2 = 0;
5344
5354
        buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5345
5355
 
5361
5371
                    break;
5362
5372
                case VC1_CODE_FIELD: {
5363
5373
                    int buf_size3;
5364
 
                    slices = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5365
 
                    if (!slices)
 
5374
                    tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
 
5375
                    if (!tmp)
5366
5376
                        goto err;
 
5377
                    slices = tmp;
5367
5378
                    slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5368
5379
                    if (!slices[n_slices].buf)
5369
5380
                        goto err;
5381
5392
                case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
5382
5393
                    buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
5383
5394
                    init_get_bits(&s->gb, buf2, buf_size2 * 8);
5384
 
                    vc1_decode_entry_point(avctx, v, &s->gb);
 
5395
                    ff_vc1_decode_entry_point(avctx, v, &s->gb);
5385
5396
                    break;
5386
5397
                case VC1_CODE_SLICE: {
5387
5398
                    int buf_size3;
5388
 
                    slices = av_realloc(slices, sizeof(*slices) * (n_slices+1));
5389
 
                    if (!slices)
 
5399
                    tmp = av_realloc(slices, sizeof(*slices) * (n_slices+1));
 
5400
                    if (!tmp)
5390
5401
                        goto err;
 
5402
                    slices = tmp;
5391
5403
                    slices[n_slices].buf = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
5392
5404
                    if (!slices[n_slices].buf)
5393
5405
                        goto err;
5435
5447
    if (v->res_sprite) {
5436
5448
        v->new_sprite  = !get_bits1(&s->gb);
5437
5449
        v->two_sprites =  get_bits1(&s->gb);
5438
 
        /* res_sprite means a Windows Media Image stream, CODEC_ID_*IMAGE means
 
5450
        /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
5439
5451
           we're using the sprite compositor. These are intentionally kept separate
5440
5452
           so you can get the raw sprites by using the wmv3 decoder for WMVP or
5441
5453
           the vc1 one for WVP2 */
5442
 
        if (avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE) {
 
5454
        if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5443
5455
            if (v->new_sprite) {
5444
5456
                // switch AVCodecContext parameters to those of the sprites
5445
5457
                avctx->width  = avctx->coded_width  = v->sprite_width;
5453
5465
    if (s->context_initialized &&
5454
5466
        (s->width  != avctx->coded_width ||
5455
5467
         s->height != avctx->coded_height)) {
5456
 
        vc1_decode_end(avctx);
 
5468
        ff_vc1_decode_end(avctx);
5457
5469
    }
5458
5470
 
5459
5471
    if (!s->context_initialized) {
5460
 
        if (ff_msmpeg4_decode_init(avctx) < 0 || vc1_decode_init_alloc_tables(v) < 0)
5461
 
            return -1;
 
5472
        if (ff_msmpeg4_decode_init(avctx) < 0 || ff_vc1_decode_init_alloc_tables(v) < 0)
 
5473
            goto err;
5462
5474
 
5463
5475
        s->low_delay = !avctx->has_b_frames || v->res_sprite;
5464
5476
 
5480
5492
    // do parse frame header
5481
5493
    v->pic_header_flag = 0;
5482
5494
    if (v->profile < PROFILE_ADVANCED) {
5483
 
        if (vc1_parse_frame_header(v, &s->gb) == -1) {
 
5495
        if (ff_vc1_parse_frame_header(v, &s->gb) == -1) {
5484
5496
            goto err;
5485
5497
        }
5486
5498
    } else {
5487
 
        if (vc1_parse_frame_header_adv(v, &s->gb) == -1) {
 
5499
        if (ff_vc1_parse_frame_header_adv(v, &s->gb) == -1) {
5488
5500
            goto err;
5489
5501
        }
5490
5502
    }
5491
5503
 
5492
 
    if ((avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE)
 
5504
    if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
5493
5505
        && s->pict_type != AV_PICTURE_TYPE_I) {
5494
5506
        av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
5495
5507
        goto err;
5512
5524
    s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
5513
5525
 
5514
5526
    /* 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)) {
 
5527
    if (s->last_picture_ptr == NULL && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
5516
5528
        goto err;
5517
5529
    }
5518
5530
    if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
5528
5540
            s->next_p_frame_damaged = 0;
5529
5541
    }
5530
5542
 
5531
 
    if (MPV_frame_start(s, avctx) < 0) {
 
5543
    if (ff_MPV_frame_start(s, avctx) < 0) {
5532
5544
        goto err;
5533
5545
    }
5534
5546
 
5549
5561
        ff_er_frame_start(s);
5550
5562
 
5551
5563
        v->bits = buf_size * 8;
 
5564
        v->end_mb_x = s->mb_width;
5552
5565
        if (v->field_mode) {
5553
5566
            uint8_t *tmp[2];
5554
5567
            s->current_picture.f.linesize[0] <<= 1;
5584
5597
            }
5585
5598
            if (i) {
5586
5599
                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)) {
 
5600
                if (v->field_mode && i == n_slices1 + 2) {
 
5601
                    if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
 
5602
                        av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
 
5603
                        continue;
 
5604
                    }
 
5605
                } else if (get_bits1(&s->gb)) {
5590
5606
                    v->pic_header_flag = 1;
5591
 
                    vc1_parse_frame_header_adv(v, &s->gb);
 
5607
                    if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
 
5608
                        av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
 
5609
                        continue;
 
5610
                    }
5592
5611
                }
5593
5612
            }
5594
5613
            s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
5596
5615
                s->end_mb_y = (i == n_slices     ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
5597
5616
            else
5598
5617
                s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
5599
 
            vc1_decode_blocks(v);
 
5618
            ff_vc1_decode_blocks(v);
5600
5619
            if (i != n_slices)
5601
5620
                s->gb = slices[i].gb;
5602
5621
        }
5612
5631
            s->linesize                      >>= 1;
5613
5632
            s->uvlinesize                    >>= 1;
5614
5633
        }
5615
 
//av_log(s->avctx, AV_LOG_INFO, "Consumed %i/%i bits\n", get_bits_count(&s->gb), s->gb.size_in_bits);
 
5634
        av_dlog(s->avctx, "Consumed %i/%i bits\n",
 
5635
                get_bits_count(&s->gb), s->gb.size_in_bits);
5616
5636
//  if (get_bits_count(&s->gb) > buf_size * 8)
5617
5637
//      return -1;
5618
5638
        ff_er_frame_end(s);
5619
5639
    }
5620
5640
 
5621
 
    MPV_frame_end(s);
 
5641
    ff_MPV_frame_end(s);
5622
5642
 
5623
 
    if (avctx->codec_id == CODEC_ID_WMV3IMAGE || avctx->codec_id == CODEC_ID_VC1IMAGE) {
 
5643
    if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
5624
5644
image:
5625
5645
        avctx->width  = avctx->coded_width  = v->output_width;
5626
5646
        avctx->height = avctx->coded_height = v->output_height;
5631
5651
            goto err;
5632
5652
#endif
5633
5653
        *pict      = v->sprite_output_frame;
5634
 
        *data_size = sizeof(AVFrame);
 
5654
        *got_frame = 1;
5635
5655
    } else {
5636
5656
        if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
5637
 
            *pict = *(AVFrame*)s->current_picture_ptr;
 
5657
            *pict = s->current_picture_ptr->f;
5638
5658
        } else if (s->last_picture_ptr != NULL) {
5639
 
            *pict = *(AVFrame*)s->last_picture_ptr;
 
5659
            *pict = s->last_picture_ptr->f;
5640
5660
        }
5641
5661
        if (s->last_picture_ptr || s->low_delay) {
5642
 
            *data_size = sizeof(AVFrame);
 
5662
            *got_frame = 1;
5643
5663
            ff_print_debug_info(s, pict);
5644
5664
        }
5645
5665
    }
5671
5691
AVCodec ff_vc1_decoder = {
5672
5692
    .name           = "vc1",
5673
5693
    .type           = AVMEDIA_TYPE_VIDEO,
5674
 
    .id             = CODEC_ID_VC1,
 
5694
    .id             = AV_CODEC_ID_VC1,
5675
5695
    .priv_data_size = sizeof(VC1Context),
5676
5696
    .init           = vc1_decode_init,
5677
 
    .close          = vc1_decode_end,
 
5697
    .close          = ff_vc1_decode_end,
5678
5698
    .decode         = vc1_decode_frame,
5679
5699
    .flush          = ff_mpeg_flush,
5680
5700
    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
5687
5707
AVCodec ff_wmv3_decoder = {
5688
5708
    .name           = "wmv3",
5689
5709
    .type           = AVMEDIA_TYPE_VIDEO,
5690
 
    .id             = CODEC_ID_WMV3,
 
5710
    .id             = AV_CODEC_ID_WMV3,
5691
5711
    .priv_data_size = sizeof(VC1Context),
5692
5712
    .init           = vc1_decode_init,
5693
 
    .close          = vc1_decode_end,
 
5713
    .close          = ff_vc1_decode_end,
5694
5714
    .decode         = vc1_decode_frame,
5695
5715
    .flush          = ff_mpeg_flush,
5696
5716
    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
5704
5724
AVCodec ff_wmv3_vdpau_decoder = {
5705
5725
    .name           = "wmv3_vdpau",
5706
5726
    .type           = AVMEDIA_TYPE_VIDEO,
5707
 
    .id             = CODEC_ID_WMV3,
 
5727
    .id             = AV_CODEC_ID_WMV3,
5708
5728
    .priv_data_size = sizeof(VC1Context),
5709
5729
    .init           = vc1_decode_init,
5710
 
    .close          = vc1_decode_end,
 
5730
    .close          = ff_vc1_decode_end,
5711
5731
    .decode         = vc1_decode_frame,
5712
5732
    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
5713
5733
    .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
5714
 
    .pix_fmts       = (const enum PixelFormat[]){PIX_FMT_VDPAU_WMV3, PIX_FMT_NONE},
 
5734
    .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_WMV3, AV_PIX_FMT_NONE },
5715
5735
    .profiles       = NULL_IF_CONFIG_SMALL(profiles)
5716
5736
};
5717
5737
#endif
5720
5740
AVCodec ff_vc1_vdpau_decoder = {
5721
5741
    .name           = "vc1_vdpau",
5722
5742
    .type           = AVMEDIA_TYPE_VIDEO,
5723
 
    .id             = CODEC_ID_VC1,
 
5743
    .id             = AV_CODEC_ID_VC1,
5724
5744
    .priv_data_size = sizeof(VC1Context),
5725
5745
    .init           = vc1_decode_init,
5726
 
    .close          = vc1_decode_end,
 
5746
    .close          = ff_vc1_decode_end,
5727
5747
    .decode         = vc1_decode_frame,
5728
5748
    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU,
5729
5749
    .long_name      = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
5730
 
    .pix_fmts       = (const enum PixelFormat[]){PIX_FMT_VDPAU_VC1, PIX_FMT_NONE},
 
5750
    .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_VC1, AV_PIX_FMT_NONE },
5731
5751
    .profiles       = NULL_IF_CONFIG_SMALL(profiles)
5732
5752
};
5733
5753
#endif
5736
5756
AVCodec ff_wmv3image_decoder = {
5737
5757
    .name           = "wmv3image",
5738
5758
    .type           = AVMEDIA_TYPE_VIDEO,
5739
 
    .id             = CODEC_ID_WMV3IMAGE,
 
5759
    .id             = AV_CODEC_ID_WMV3IMAGE,
5740
5760
    .priv_data_size = sizeof(VC1Context),
5741
5761
    .init           = vc1_decode_init,
5742
 
    .close          = vc1_decode_end,
 
5762
    .close          = ff_vc1_decode_end,
5743
5763
    .decode         = vc1_decode_frame,
5744
5764
    .capabilities   = CODEC_CAP_DR1,
5745
5765
    .flush          = vc1_sprite_flush,
5752
5772
AVCodec ff_vc1image_decoder = {
5753
5773
    .name           = "vc1image",
5754
5774
    .type           = AVMEDIA_TYPE_VIDEO,
5755
 
    .id             = CODEC_ID_VC1IMAGE,
 
5775
    .id             = AV_CODEC_ID_VC1IMAGE,
5756
5776
    .priv_data_size = sizeof(VC1Context),
5757
5777
    .init           = vc1_decode_init,
5758
 
    .close          = vc1_decode_end,
 
5778
    .close          = ff_vc1_decode_end,
5759
5779
    .decode         = vc1_decode_frame,
5760
5780
    .capabilities   = CODEC_CAP_DR1,
5761
5781
    .flush          = vc1_sprite_flush,