vc1_parser.c 6.05 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
/*
 * VC-1 and WMV3 parser
 * Copyright (c) 2006-2007 Konstantin Shishkov
 * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
24
 * @file
25 26
 * VC-1 and WMV3 parser
 */
27

28
#include "libavutil/attributes.h"
29 30
#include "parser.h"
#include "vc1.h"
31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
#include "get_bits.h"

typedef struct {
    ParseContext pc;
    VC1Context v;
} VC1ParseContext;

static void vc1_extract_headers(AVCodecParserContext *s, AVCodecContext *avctx,
                                const uint8_t *buf, int buf_size)
{
    VC1ParseContext *vpc = s->priv_data;
    GetBitContext gb;
    const uint8_t *start, *end, *next;
    uint8_t *buf2 = av_mallocz(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);

    vpc->v.s.avctx = avctx;
    vpc->v.parse_only = 1;
48
    vpc->v.first_pic_header_flag = 1;
49
    next = buf;
50
    s->repeat_pict = 0;
51 52 53 54 55 56 57 58 59 60 61

    for(start = buf, end = buf + buf_size; next < end; start = next){
        int buf2_size, size;

        next = find_next_marker(start + 4, end);
        size = next - start - 4;
        buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
        init_get_bits(&gb, buf2, buf2_size * 8);
        if(size <= 0) continue;
        switch(AV_RB32(start)){
        case VC1_CODE_SEQHDR:
62
            ff_vc1_decode_sequence_header(avctx, &vpc->v, &gb);
63 64
            break;
        case VC1_CODE_ENTRYPOINT:
65
            ff_vc1_decode_entry_point(avctx, &vpc->v, &gb);
66 67 68
            break;
        case VC1_CODE_FRAME:
            if(vpc->v.profile < PROFILE_ADVANCED)
69
                ff_vc1_parse_frame_header    (&vpc->v, &gb);
70
            else
71
                ff_vc1_parse_frame_header_adv(&vpc->v, &gb);
72

73 74 75
            /* keep AV_PICTURE_TYPE_BI internal to VC1 */
            if (vpc->v.s.pict_type == AV_PICTURE_TYPE_BI)
                s->pict_type = AV_PICTURE_TYPE_B;
76 77 78
            else
                s->pict_type = vpc->v.s.pict_type;

79 80 81 82 83 84 85 86 87 88 89 90 91 92
            if (avctx->ticks_per_frame > 1){
                // process pulldown flags
                s->repeat_pict = 1;
                // Pulldown flags are only valid when 'broadcast' has been set.
                // So ticks_per_frame will be 2
                if (vpc->v.rff){
                    // repeat field
                    s->repeat_pict = 2;
                }else if (vpc->v.rptfrm){
                    // repeat frames
                    s->repeat_pict = vpc->v.rptfrm * 2 + 1;
                }
            }

93 94 95 96 97
            if (vpc->v.broadcast && vpc->v.interlace && !vpc->v.psf)
                s->field_order = vpc->v.tff ? AV_FIELD_TT : AV_FIELD_BB;
            else
                s->field_order = AV_FIELD_PROGRESSIVE;

98 99 100 101 102 103
            break;
        }
    }

    av_free(buf2);
}
104 105

/**
106
 * Find the end of the current frame in the bitstream.
107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148
 * @return the position of the first byte of the next frame, or -1
 */
static int vc1_find_frame_end(ParseContext *pc, const uint8_t *buf,
                               int buf_size) {
    int pic_found, i;
    uint32_t state;

    pic_found= pc->frame_start_found;
    state= pc->state;

    i=0;
    if(!pic_found){
        for(i=0; i<buf_size; i++){
            state= (state<<8) | buf[i];
            if(state == VC1_CODE_FRAME || state == VC1_CODE_FIELD){
                i++;
                pic_found=1;
                break;
            }
        }
    }

    if(pic_found){
        /* EOF considered as end of frame */
        if (buf_size == 0)
            return 0;
        for(; i<buf_size; i++){
            state= (state<<8) | buf[i];
            if(IS_MARKER(state) && state != VC1_CODE_FIELD && state != VC1_CODE_SLICE){
                pc->frame_start_found=0;
                pc->state=-1;
                return i-3;
            }
        }
    }
    pc->frame_start_found= pic_found;
    pc->state= state;
    return END_NOT_FOUND;
}

static int vc1_parse(AVCodecParserContext *s,
                           AVCodecContext *avctx,
149
                           const uint8_t **poutbuf, int *poutbuf_size,
150 151
                           const uint8_t *buf, int buf_size)
{
152
    VC1ParseContext *vpc = s->priv_data;
153 154 155 156 157
    int next;

    if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
        next= buf_size;
    }else{
158
        next= vc1_find_frame_end(&vpc->pc, buf, buf_size);
159

160
        if (ff_combine_frame(&vpc->pc, next, &buf, &buf_size) < 0) {
161 162 163 164 165
            *poutbuf = NULL;
            *poutbuf_size = 0;
            return buf_size;
        }
    }
166 167 168

    vc1_extract_headers(s, avctx, buf, buf_size);

169
    *poutbuf = buf;
170 171 172 173 174 175 176 177 178
    *poutbuf_size = buf_size;
    return next;
}

static int vc1_split(AVCodecContext *avctx,
                           const uint8_t *buf, int buf_size)
{
    int i;
    uint32_t state= -1;
Michael Niedermayer's avatar
Michael Niedermayer committed
179
    int charged=0;
180 181 182

    for(i=0; i<buf_size; i++){
        state= (state<<8) | buf[i];
Michael Niedermayer's avatar
Michael Niedermayer committed
183 184 185 186 187 188 189
        if(IS_MARKER(state)){
            if(state == VC1_CODE_SEQHDR || state == VC1_CODE_ENTRYPOINT){
                charged=1;
            }else if(charged){
                return i-3;
            }
        }
190 191 192 193
    }
    return 0;
}

194
static av_cold int vc1_parse_init(AVCodecParserContext *s)
195 196 197
{
    VC1ParseContext *vpc = s->priv_data;
    vpc->v.s.slice_context_count = 1;
198
    return ff_vc1_init_common(&vpc->v);
199 200
}

201
AVCodecParser ff_vc1_parser = {
202
    .codec_ids      = { AV_CODEC_ID_VC1 },
203
    .priv_data_size = sizeof(VC1ParseContext),
204
    .parser_init    = vc1_parse_init,
205
    .parser_parse   = vc1_parse,
Rafaël Carré's avatar
Rafaël Carré committed
206
    .parser_close   = ff_parse_close,
207
    .split          = vc1_split,
208
};