← Back to branch summary

~ubuntu-branches/ubuntu/vivid/ffmpeg/vivid

« back to all changes in this revision

Viewing changes to libavcodec/h264_parser.c

  • Committer: Package Import Robot
  • Author(s): Andreas Cadhalpun
  • Date: 2014-11-05 01:18:23 UTC
  • mfrom: (0.2.17 sid)
  • Revision ID: package-import@ubuntu.com-20141105011823-xsbeceffs43wtkn7
Tags: 7:2.4.3-1
* Import new upstream bugfix release 2.4.3.
   - Refresh Change-symbol-versioning.patch.
   - Add new symbols to the libavdevice symbols file.
* Enable libbs2b on arm64, since it is now available.
* Disable frei0r and libx264 on x32, libsoxr and openal on sparc64
  and libopencv on m68k, sh4, sparc64 and x32, because they are not
  (yet) avialable there.
* Disable assembler optimizations on x32, as they wouldn't work there.
* Include config.log in the build-log, when compiling fails.
* Add fix-hppa-tests.patch to work around a gcc bug on hppa.

Show diffs side-by-side

added added

removed removed

Lines of Context:
libavcodec/h264_parser.c
25
25
 * @author Michael Niedermayer <michaelni@gmx.at>
26
26
 */
27
27
 
 
28
#define UNCHECKED_BITSTREAM_READER 1
 
29
 
 
30
#include "libavutil/attributes.h"
28
31
#include "parser.h"
29
 
#include "h264_parser.h"
30
32
#include "h264data.h"
31
33
#include "golomb.h"
32
 
 
33
 
#include <assert.h>
34
 
 
35
 
 
36
 
int ff_h264_find_frame_end(H264Context *h, const uint8_t *buf, int buf_size)
 
34
#include "internal.h"
 
35
#include "mpegutils.h"
 
36
 
 
37
 
 
38
static int h264_find_frame_end(H264Context *h, const uint8_t *buf,
 
39
                               int buf_size)
37
40
{
38
 
    int i;
 
41
    int i, j;
39
42
    uint32_t state;
40
 
    ParseContext *pc = &(h->s.parse_context);
41
 
//printf("first %02X%02X%02X%02X\n", buf[0], buf[1],buf[2],buf[3]);
 
43
    ParseContext *pc = &h->parse_context;
 
44
    int next_avc= h->is_avc ? 0 : buf_size;
 
45
 
42
46
//    mb_addr= pc->mb_addr - 1;
43
 
    state= pc->state;
44
 
    if(state>13)
45
 
        state= 7;
46
 
 
47
 
    for(i=0; i<buf_size; i++){
48
 
        if(state==7){
49
 
#if HAVE_FAST_UNALIGNED
50
 
        /* we check i<buf_size instead of i+3/7 because its simpler
51
 
         * and there should be FF_INPUT_BUFFER_PADDING_SIZE bytes at the end
52
 
         */
53
 
#    if HAVE_FAST_64BIT
54
 
            while(i<buf_size && !((~*(const uint64_t*)(buf+i) & (*(const uint64_t*)(buf+i) - 0x0101010101010101ULL)) & 0x8080808080808080ULL))
55
 
                i+=8;
56
 
#    else
57
 
            while(i<buf_size && !((~*(const uint32_t*)(buf+i) & (*(const uint32_t*)(buf+i) - 0x01010101U)) & 0x80808080U))
58
 
                i+=4;
59
 
#    endif
60
 
#endif
61
 
            for(; i<buf_size; i++){
62
 
                if(!buf[i]){
63
 
                    state=2;
64
 
                    break;
65
 
                }
 
47
    state = pc->state;
 
48
    if (state > 13)
 
49
        state = 7;
 
50
 
 
51
    if (h->is_avc && !h->nal_length_size)
 
52
        av_log(h->avctx, AV_LOG_ERROR, "AVC-parser: nal length size invalid\n");
 
53
 
 
54
    for (i = 0; i < buf_size; i++) {
 
55
        if (i >= next_avc) {
 
56
            int nalsize = 0;
 
57
            i = next_avc;
 
58
            for (j = 0; j < h->nal_length_size; j++)
 
59
                nalsize = (nalsize << 8) | buf[i++];
 
60
            if (nalsize <= 0 || nalsize > buf_size - i) {
 
61
                av_log(h->avctx, AV_LOG_ERROR, "AVC-parser: nal size %d remaining %d\n", nalsize, buf_size - i);
 
62
                return buf_size;
66
63
            }
67
 
        }else if(state<=2){
68
 
            if(buf[i]==1)   state^= 5; //2->7, 1->4, 0->5
69
 
            else if(buf[i]) state = 7;
70
 
            else            state>>=1; //2->1, 1->0, 0->0
71
 
        }else if(state<=5){
72
 
            int v= buf[i] & 0x1F;
73
 
            if(v==6 || v==7 || v==8 || v==9){
74
 
                if(pc->frame_start_found){
 
64
            next_avc = i + nalsize;
 
65
            state    = 5;
 
66
        }
 
67
 
 
68
        if (state == 7) {
 
69
            i += h->h264dsp.startcode_find_candidate(buf + i, next_avc - i);
 
70
            if (i < next_avc)
 
71
                state = 2;
 
72
        } else if (state <= 2) {
 
73
            if (buf[i] == 1)
 
74
                state ^= 5;            // 2->7, 1->4, 0->5
 
75
            else if (buf[i])
 
76
                state = 7;
 
77
            else
 
78
                state >>= 1;           // 2->1, 1->0, 0->0
 
79
        } else if (state <= 5) {
 
80
            int nalu_type = buf[i] & 0x1F;
 
81
            if (nalu_type == NAL_SEI || nalu_type == NAL_SPS ||
 
82
                nalu_type == NAL_PPS || nalu_type == NAL_AUD) {
 
83
                if (pc->frame_start_found) {
75
84
                    i++;
76
85
                    goto found;
77
86
                }
78
 
            }else if(v==1 || v==2 || v==5){
79
 
                if(pc->frame_start_found){
80
 
                    state+=8;
81
 
                    continue;
82
 
                }else
 
87
            } else if (nalu_type == NAL_SLICE || nalu_type == NAL_DPA ||
 
88
                       nalu_type == NAL_IDR_SLICE) {
 
89
                state += 8;
 
90
                continue;
 
91
            }
 
92
            state = 7;
 
93
        } else {
 
94
            h->parse_history[h->parse_history_count++]= buf[i];
 
95
            if (h->parse_history_count>5) {
 
96
                unsigned int mb, last_mb= h->parse_last_mb;
 
97
                GetBitContext gb;
 
98
 
 
99
                init_get_bits(&gb, h->parse_history, 8*h->parse_history_count);
 
100
                h->parse_history_count=0;
 
101
                mb= get_ue_golomb_long(&gb);
 
102
                h->parse_last_mb= mb;
 
103
                if (pc->frame_start_found) {
 
104
                    if (mb <= last_mb)
 
105
                        goto found;
 
106
                } else
83
107
                    pc->frame_start_found = 1;
 
108
                state = 7;
84
109
            }
85
 
            state= 7;
86
 
        }else{
87
 
            if(buf[i] & 0x80)
88
 
                goto found;
89
 
            state= 7;
90
110
        }
91
111
    }
92
 
    pc->state= state;
 
112
    pc->state = state;
 
113
    if (h->is_avc)
 
114
        return next_avc;
93
115
    return END_NOT_FOUND;
94
116
 
95
117
found:
96
 
    pc->state=7;
97
 
    pc->frame_start_found= 0;
98
 
    return i-(state&5);
99
 
}
100
 
 
101
 
/*!
 
118
    pc->state             = 7;
 
119
    pc->frame_start_found = 0;
 
120
    if (h->is_avc)
 
121
        return next_avc;
 
122
    return i - (state & 5) - 5 * (state > 7);
 
123
}
 
124
 
 
125
static int scan_mmco_reset(AVCodecParserContext *s)
 
126
{
 
127
    H264Context *h = s->priv_data;
 
128
 
 
129
    h->slice_type_nos = s->pict_type & 3;
 
130
 
 
131
    if (h->pps.redundant_pic_cnt_present)
 
132
        get_ue_golomb(&h->gb); // redundant_pic_count
 
133
 
 
134
    if (ff_set_ref_count(h) < 0)
 
135
        return AVERROR_INVALIDDATA;
 
136
 
 
137
    if (h->slice_type_nos != AV_PICTURE_TYPE_I) {
 
138
        int list;
 
139
        for (list = 0; list < h->list_count; list++) {
 
140
            if (get_bits1(&h->gb)) {
 
141
                int index;
 
142
                for (index = 0; ; index++) {
 
143
                    unsigned int reordering_of_pic_nums_idc = get_ue_golomb_31(&h->gb);
 
144
 
 
145
                    if (reordering_of_pic_nums_idc < 3)
 
146
                        get_ue_golomb(&h->gb);
 
147
                    else if (reordering_of_pic_nums_idc > 3) {
 
148
                        av_log(h->avctx, AV_LOG_ERROR,
 
149
                               "illegal reordering_of_pic_nums_idc %d\n",
 
150
                               reordering_of_pic_nums_idc);
 
151
                        return AVERROR_INVALIDDATA;
 
152
                    } else
 
153
                        break;
 
154
 
 
155
                    if (index >= h->ref_count[list]) {
 
156
                        av_log(h->avctx, AV_LOG_ERROR,
 
157
                               "reference count %d overflow\n", index);
 
158
                        return AVERROR_INVALIDDATA;
 
159
                    }
 
160
                }
 
161
            }
 
162
        }
 
163
    }
 
164
 
 
165
    if ((h->pps.weighted_pred && h->slice_type_nos == AV_PICTURE_TYPE_P) ||
 
166
        (h->pps.weighted_bipred_idc == 1 && h->slice_type_nos == AV_PICTURE_TYPE_B))
 
167
        ff_pred_weight_table(h);
 
168
 
 
169
    if (get_bits1(&h->gb)) { // adaptive_ref_pic_marking_mode_flag
 
170
        int i;
 
171
        for (i = 0; i < MAX_MMCO_COUNT; i++) {
 
172
            MMCOOpcode opcode = get_ue_golomb_31(&h->gb);
 
173
            if (opcode > (unsigned) MMCO_LONG) {
 
174
                av_log(h->avctx, AV_LOG_ERROR,
 
175
                       "illegal memory management control operation %d\n",
 
176
                       opcode);
 
177
                return AVERROR_INVALIDDATA;
 
178
            }
 
179
            if (opcode == MMCO_END)
 
180
               return 0;
 
181
            else if (opcode == MMCO_RESET)
 
182
                return 1;
 
183
 
 
184
            if (opcode == MMCO_SHORT2UNUSED || opcode == MMCO_SHORT2LONG)
 
185
                get_ue_golomb(&h->gb);
 
186
            if (opcode == MMCO_SHORT2LONG || opcode == MMCO_LONG2UNUSED ||
 
187
                opcode == MMCO_LONG || opcode == MMCO_SET_MAX_LONG)
 
188
                get_ue_golomb_31(&h->gb);
 
189
        }
 
190
    }
 
191
 
 
192
    return 0;
 
193
}
 
194
 
 
195
/**
102
196
 * Parse NAL units of found picture and decode some basic information.
103
197
 *
104
198
 * @param s parser context.
108
202
 */
109
203
static inline int parse_nal_units(AVCodecParserContext *s,
110
204
                                  AVCodecContext *avctx,
111
 
                                  const uint8_t *buf, int buf_size)
 
205
                                  const uint8_t * const buf, int buf_size)
112
206
{
113
 
    H264Context *h = s->priv_data;
114
 
    const uint8_t *buf_end = buf + buf_size;
 
207
    H264Context *h         = s->priv_data;
 
208
    int buf_index, next_avc;
115
209
    unsigned int pps_id;
116
210
    unsigned int slice_type;
117
 
    int state = -1;
 
211
    int state = -1, got_reset = 0;
118
212
    const uint8_t *ptr;
 
213
    int q264 = buf_size >=4 && !memcmp("Q264", buf, 4);
 
214
    int field_poc[2];
119
215
 
120
216
    /* set some sane default values */
121
 
    s->pict_type = FF_I_TYPE;
122
 
    s->key_frame = 0;
123
 
 
124
 
    h->s.avctx= avctx;
125
 
    h->sei_recovery_frame_cnt = -1;
126
 
    h->sei_dpb_output_delay         =  0;
127
 
    h->sei_cpb_removal_delay        = -1;
128
 
    h->sei_buffering_period_present =  0;
129
 
 
130
 
    for(;;) {
131
 
        int src_length, dst_length, consumed;
132
 
        buf = ff_find_start_code(buf, buf_end, &state);
133
 
        if(buf >= buf_end)
134
 
            break;
135
 
        --buf;
136
 
        src_length = buf_end - buf;
 
217
    s->pict_type         = AV_PICTURE_TYPE_I;
 
218
    s->key_frame         = 0;
 
219
    s->picture_structure = AV_PICTURE_STRUCTURE_UNKNOWN;
 
220
 
 
221
    h->avctx = avctx;
 
222
    ff_h264_reset_sei(h);
 
223
    h->sei_fpa.frame_packing_arrangement_cancel_flag = -1;
 
224
 
 
225
    if (!buf_size)
 
226
        return 0;
 
227
 
 
228
    buf_index     = 0;
 
229
    next_avc      = h->is_avc ? 0 : buf_size;
 
230
    for (;;) {
 
231
        int src_length, dst_length, consumed, nalsize = 0;
 
232
 
 
233
        if (buf_index >= next_avc) {
 
234
            nalsize = get_avc_nalsize(h, buf, buf_size, &buf_index);
 
235
            if (nalsize < 0)
 
236
                break;
 
237
            next_avc = buf_index + nalsize;
 
238
        } else {
 
239
            buf_index = find_start_code(buf, buf_size, buf_index, next_avc);
 
240
            if (buf_index >= buf_size)
 
241
                break;
 
242
            if (buf_index >= next_avc)
 
243
                continue;
 
244
        }
 
245
        src_length = next_avc - buf_index;
 
246
 
 
247
        state = buf[buf_index];
137
248
        switch (state & 0x1f) {
138
249
        case NAL_SLICE:
139
250
        case NAL_IDR_SLICE:
140
251
            // Do not walk the whole buffer just to decode slice header
141
 
            if (src_length > 20)
142
 
                src_length = 20;
 
252
            if ((state & 0x1f) == NAL_IDR_SLICE || ((state >> 5) & 0x3) == 0) {
 
253
                /* IDR or disposable slice
 
254
                 * No need to decode many bytes because MMCOs shall not be present. */
 
255
                if (src_length > 60)
 
256
                    src_length = 60;
 
257
            } else {
 
258
                /* To decode up to MMCOs */
 
259
                if (src_length > 1000)
 
260
                    src_length = 1000;
 
261
            }
143
262
            break;
144
263
        }
145
 
        ptr= ff_h264_decode_nal(h, buf, &dst_length, &consumed, src_length);
146
 
        if (ptr==NULL || dst_length < 0)
 
264
        ptr = ff_h264_decode_nal(h, buf + buf_index, &dst_length,
 
265
                                 &consumed, src_length);
 
266
        if (!ptr || dst_length < 0)
147
267
            break;
148
268
 
149
 
        init_get_bits(&h->s.gb, ptr, 8*dst_length);
150
 
        switch(h->nal_unit_type) {
 
269
        buf_index += consumed;
 
270
 
 
271
        init_get_bits(&h->gb, ptr, 8 * dst_length);
 
272
        switch (h->nal_unit_type) {
151
273
        case NAL_SPS:
152
274
            ff_h264_decode_seq_parameter_set(h);
153
275
            break;
154
276
        case NAL_PPS:
155
 
            ff_h264_decode_picture_parameter_set(h, h->s.gb.size_in_bits);
 
277
            ff_h264_decode_picture_parameter_set(h, h->gb.size_in_bits);
156
278
            break;
157
279
        case NAL_SEI:
158
280
            ff_h264_decode_sei(h);
159
281
            break;
160
282
        case NAL_IDR_SLICE:
161
283
            s->key_frame = 1;
162
 
            /* fall through */
 
284
 
 
285
            h->prev_frame_num        = 0;
 
286
            h->prev_frame_num_offset = 0;
 
287
            h->prev_poc_msb          =
 
288
            h->prev_poc_lsb          = 0;
 
289
        /* fall through */
163
290
        case NAL_SLICE:
164
 
            get_ue_golomb(&h->s.gb);  // skip first_mb_in_slice
165
 
            slice_type = get_ue_golomb_31(&h->s.gb);
 
291
            get_ue_golomb_long(&h->gb);  // skip first_mb_in_slice
 
292
            slice_type   = get_ue_golomb_31(&h->gb);
166
293
            s->pict_type = golomb_to_pict_type[slice_type % 5];
167
294
            if (h->sei_recovery_frame_cnt >= 0) {
168
295
                /* key frame, since recovery_frame_cnt is set */
169
296
                s->key_frame = 1;
170
297
            }
171
 
            pps_id= get_ue_golomb(&h->s.gb);
172
 
            if(pps_id>=MAX_PPS_COUNT) {
173
 
                av_log(h->s.avctx, AV_LOG_ERROR, "pps_id out of range\n");
174
 
                return -1;
175
 
            }
176
 
            if(!h->pps_buffers[pps_id]) {
177
 
                av_log(h->s.avctx, AV_LOG_ERROR, "non-existing PPS referenced\n");
178
 
                return -1;
179
 
            }
180
 
            h->pps= *h->pps_buffers[pps_id];
181
 
            if(!h->sps_buffers[h->pps.sps_id]) {
182
 
                av_log(h->s.avctx, AV_LOG_ERROR, "non-existing SPS referenced\n");
183
 
                return -1;
184
 
            }
185
 
            h->sps = *h->sps_buffers[h->pps.sps_id];
186
 
            h->frame_num = get_bits(&h->s.gb, h->sps.log2_max_frame_num);
187
 
 
188
 
            avctx->profile = h->sps.profile_idc;
 
298
            pps_id = get_ue_golomb(&h->gb);
 
299
            if (pps_id >= MAX_PPS_COUNT) {
 
300
                av_log(h->avctx, AV_LOG_ERROR,
 
301
                       "pps_id %u out of range\n", pps_id);
 
302
                return -1;
 
303
            }
 
304
            if (!h->pps_buffers[pps_id]) {
 
305
                av_log(h->avctx, AV_LOG_ERROR,
 
306
                       "non-existing PPS %u referenced\n", pps_id);
 
307
                return -1;
 
308
            }
 
309
            h->pps = *h->pps_buffers[pps_id];
 
310
            if (!h->sps_buffers[h->pps.sps_id]) {
 
311
                av_log(h->avctx, AV_LOG_ERROR,
 
312
                       "non-existing SPS %u referenced\n", h->pps.sps_id);
 
313
                return -1;
 
314
            }
 
315
            h->sps       = *h->sps_buffers[h->pps.sps_id];
 
316
            h->frame_num = get_bits(&h->gb, h->sps.log2_max_frame_num);
 
317
 
 
318
            if(h->sps.ref_frame_count <= 1 && h->pps.ref_count[0] <= 1 && s->pict_type == AV_PICTURE_TYPE_I)
 
319
                s->key_frame = 1;
 
320
 
 
321
            avctx->profile = ff_h264_get_profile(&h->sps);
189
322
            avctx->level   = h->sps.level_idc;
190
323
 
191
 
            if(h->sps.frame_mbs_only_flag){
192
 
                h->s.picture_structure= PICT_FRAME;
193
 
            }else{
194
 
                if(get_bits1(&h->s.gb)) { //field_pic_flag
195
 
                    h->s.picture_structure= PICT_TOP_FIELD + get_bits1(&h->s.gb); //bottom_field_flag
196
 
                } else {
197
 
                    h->s.picture_structure= PICT_FRAME;
198
 
                }
199
 
            }
200
 
 
201
 
            if(h->sps.pic_struct_present_flag) {
 
324
            if (h->sps.frame_mbs_only_flag) {
 
325
                h->picture_structure = PICT_FRAME;
 
326
            } else {
 
327
                if (get_bits1(&h->gb)) { // field_pic_flag
 
328
                    h->picture_structure = PICT_TOP_FIELD + get_bits1(&h->gb); // bottom_field_flag
 
329
                } else {
 
330
                    h->picture_structure = PICT_FRAME;
 
331
                }
 
332
            }
 
333
 
 
334
            if (h->nal_unit_type == NAL_IDR_SLICE)
 
335
                get_ue_golomb(&h->gb); /* idr_pic_id */
 
336
            if (h->sps.poc_type == 0) {
 
337
                h->poc_lsb = get_bits(&h->gb, h->sps.log2_max_poc_lsb);
 
338
 
 
339
                if (h->pps.pic_order_present == 1 &&
 
340
                    h->picture_structure == PICT_FRAME)
 
341
                    h->delta_poc_bottom = get_se_golomb(&h->gb);
 
342
            }
 
343
 
 
344
            if (h->sps.poc_type == 1 &&
 
345
                !h->sps.delta_pic_order_always_zero_flag) {
 
346
                h->delta_poc[0] = get_se_golomb(&h->gb);
 
347
 
 
348
                if (h->pps.pic_order_present == 1 &&
 
349
                    h->picture_structure == PICT_FRAME)
 
350
                    h->delta_poc[1] = get_se_golomb(&h->gb);
 
351
            }
 
352
 
 
353
            /* Decode POC of this picture.
 
354
             * The prev_ values needed for decoding POC of the next picture are not set here. */
 
355
            field_poc[0] = field_poc[1] = INT_MAX;
 
356
            ff_init_poc(h, field_poc, &s->output_picture_number);
 
357
 
 
358
            /* Continue parsing to check if MMCO_RESET is present.
 
359
             * FIXME: MMCO_RESET could appear in non-first slice.
 
360
             *        Maybe, we should parse all undisposable non-IDR slice of this
 
361
             *        picture until encountering MMCO_RESET in a slice of it. */
 
362
            if (h->nal_ref_idc && h->nal_unit_type != NAL_IDR_SLICE) {
 
363
                got_reset = scan_mmco_reset(s);
 
364
                if (got_reset < 0)
 
365
                    return got_reset;
 
366
            }
 
367
 
 
368
            /* Set up the prev_ values for decoding POC of the next picture. */
 
369
            h->prev_frame_num        = got_reset ? 0 : h->frame_num;
 
370
            h->prev_frame_num_offset = got_reset ? 0 : h->frame_num_offset;
 
371
            if (h->nal_ref_idc != 0) {
 
372
                if (!got_reset) {
 
373
                    h->prev_poc_msb = h->poc_msb;
 
374
                    h->prev_poc_lsb = h->poc_lsb;
 
375
                } else {
 
376
                    h->prev_poc_msb = 0;
 
377
                    h->prev_poc_lsb =
 
378
                        h->picture_structure == PICT_BOTTOM_FIELD ? 0 : field_poc[0];
 
379
                }
 
380
            }
 
381
 
 
382
            if (h->sps.pic_struct_present_flag) {
202
383
                switch (h->sei_pic_struct) {
203
 
                    case SEI_PIC_STRUCT_TOP_FIELD:
204
 
                    case SEI_PIC_STRUCT_BOTTOM_FIELD:
205
 
                        s->repeat_pict = 0;
206
 
                        break;
207
 
                    case SEI_PIC_STRUCT_FRAME:
 
384
                case SEI_PIC_STRUCT_TOP_FIELD:
 
385
                case SEI_PIC_STRUCT_BOTTOM_FIELD:
 
386
                    s->repeat_pict = 0;
 
387
                    break;
 
388
                case SEI_PIC_STRUCT_FRAME:
 
389
                case SEI_PIC_STRUCT_TOP_BOTTOM:
 
390
                case SEI_PIC_STRUCT_BOTTOM_TOP:
 
391
                    s->repeat_pict = 1;
 
392
                    break;
 
393
                case SEI_PIC_STRUCT_TOP_BOTTOM_TOP:
 
394
                case SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:
 
395
                    s->repeat_pict = 2;
 
396
                    break;
 
397
                case SEI_PIC_STRUCT_FRAME_DOUBLING:
 
398
                    s->repeat_pict = 3;
 
399
                    break;
 
400
                case SEI_PIC_STRUCT_FRAME_TRIPLING:
 
401
                    s->repeat_pict = 5;
 
402
                    break;
 
403
                default:
 
404
                    s->repeat_pict = h->picture_structure == PICT_FRAME ? 1 : 0;
 
405
                    break;
 
406
                }
 
407
            } else {
 
408
                s->repeat_pict = h->picture_structure == PICT_FRAME ? 1 : 0;
 
409
            }
 
410
 
 
411
            if (h->picture_structure == PICT_FRAME) {
 
412
                s->picture_structure = AV_PICTURE_STRUCTURE_FRAME;
 
413
                if (h->sps.pic_struct_present_flag) {
 
414
                    switch (h->sei_pic_struct) {
208
415
                    case SEI_PIC_STRUCT_TOP_BOTTOM:
 
416
                    case SEI_PIC_STRUCT_TOP_BOTTOM_TOP:
 
417
                        s->field_order = AV_FIELD_TT;
 
418
                        break;
209
419
                    case SEI_PIC_STRUCT_BOTTOM_TOP:
210
 
                        s->repeat_pict = 1;
211
 
                        break;
212
 
                    case SEI_PIC_STRUCT_TOP_BOTTOM_TOP:
213
420
                    case SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:
214
 
                        s->repeat_pict = 2;
215
 
                        break;
216
 
                    case SEI_PIC_STRUCT_FRAME_DOUBLING:
217
 
                        s->repeat_pict = 3;
218
 
                        break;
219
 
                    case SEI_PIC_STRUCT_FRAME_TRIPLING:
220
 
                        s->repeat_pict = 5;
 
421
                        s->field_order = AV_FIELD_BB;
221
422
                        break;
222
423
                    default:
223
 
                        s->repeat_pict = h->s.picture_structure == PICT_FRAME ? 1 : 0;
 
424
                        s->field_order = AV_FIELD_PROGRESSIVE;
224
425
                        break;
 
426
                    }
 
427
                } else {
 
428
                    if (field_poc[0] < field_poc[1])
 
429
                        s->field_order = AV_FIELD_TT;
 
430
                    else if (field_poc[0] > field_poc[1])
 
431
                        s->field_order = AV_FIELD_BB;
 
432
                    else
 
433
                        s->field_order = AV_FIELD_PROGRESSIVE;
225
434
                }
226
435
            } else {
227
 
                s->repeat_pict = h->s.picture_structure == PICT_FRAME ? 1 : 0;
 
436
                if (h->picture_structure == PICT_TOP_FIELD)
 
437
                    s->picture_structure = AV_PICTURE_STRUCTURE_TOP_FIELD;
 
438
                else
 
439
                    s->picture_structure = AV_PICTURE_STRUCTURE_BOTTOM_FIELD;
 
440
                s->field_order = AV_FIELD_UNKNOWN;
228
441
            }
229
442
 
230
443
            return 0; /* no need to evaluate the rest */
231
444
        }
232
 
        buf += consumed;
233
445
    }
 
446
    if (q264)
 
447
        return 0;
234
448
    /* didn't find a picture! */
235
 
    av_log(h->s.avctx, AV_LOG_ERROR, "missing picture in access unit\n");
 
449
    av_log(h->avctx, AV_LOG_ERROR, "missing picture in access unit with size %d\n", buf_size);
236
450
    return -1;
237
451
}
238
452
 
241
455
                      const uint8_t **poutbuf, int *poutbuf_size,
242
456
                      const uint8_t *buf, int buf_size)
243
457
{
244
 
    H264Context *h = s->priv_data;
245
 
    ParseContext *pc = &h->s.parse_context;
 
458
    H264Context *h   = s->priv_data;
 
459
    ParseContext *pc = &h->parse_context;
246
460
    int next;
247
461
 
248
 
    if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
249
 
        next= buf_size;
250
 
    }else{
251
 
        next= ff_h264_find_frame_end(h, buf, buf_size);
 
462
    if (!h->got_first) {
 
463
        h->got_first = 1;
 
464
        if (avctx->extradata_size) {
 
465
            h->avctx = avctx;
 
466
            // must be done like in decoder, otherwise opening the parser,
 
467
            // letting it create extradata and then closing and opening again
 
468
            // will cause has_b_frames to be always set.
 
469
            // Note that estimate_timings_from_pts does exactly this.
 
470
            if (!avctx->has_b_frames)
 
471
                h->low_delay = 1;
 
472
            ff_h264_decode_extradata(h, avctx->extradata, avctx->extradata_size);
 
473
        }
 
474
    }
 
475
 
 
476
    if (s->flags & PARSER_FLAG_COMPLETE_FRAMES) {
 
477
        next = buf_size;
 
478
    } else {
 
479
        next = h264_find_frame_end(h, buf, buf_size);
252
480
 
253
481
        if (ff_combine_frame(pc, next, &buf, &buf_size) < 0) {
254
 
            *poutbuf = NULL;
 
482
            *poutbuf      = NULL;
255
483
            *poutbuf_size = 0;
256
484
            return buf_size;
257
485
        }
258
486
 
259
 
        if(next<0 && next != END_NOT_FOUND){
260
 
            assert(pc->last_index + next >= 0 );
261
 
            ff_h264_find_frame_end(h, &pc->buffer[pc->last_index + next], -next); //update state
262
 
        }
263
 
 
264
 
        parse_nal_units(s, avctx, buf, buf_size);
265
 
 
266
 
        if (h->sei_cpb_removal_delay >= 0) {
267
 
            s->dts_sync_point    = h->sei_buffering_period_present;
268
 
            s->dts_ref_dts_delta = h->sei_cpb_removal_delay;
269
 
            s->pts_dts_delta     = h->sei_dpb_output_delay;
270
 
        } else {
271
 
            s->dts_sync_point    = INT_MIN;
272
 
            s->dts_ref_dts_delta = INT_MIN;
273
 
            s->pts_dts_delta     = INT_MIN;
274
 
        }
275
 
    }
276
 
 
277
 
    *poutbuf = buf;
 
487
        if (next < 0 && next != END_NOT_FOUND) {
 
488
            av_assert1(pc->last_index + next >= 0);
 
489
            h264_find_frame_end(h, &pc->buffer[pc->last_index + next], -next); // update state
 
490
        }
 
491
    }
 
492
 
 
493
    parse_nal_units(s, avctx, buf, buf_size);
 
494
 
 
495
    if (h->sei_cpb_removal_delay >= 0) {
 
496
        s->dts_sync_point    = h->sei_buffering_period_present;
 
497
        s->dts_ref_dts_delta = h->sei_cpb_removal_delay;
 
498
        s->pts_dts_delta     = h->sei_dpb_output_delay;
 
499
    } else {
 
500
        s->dts_sync_point    = INT_MIN;
 
501
        s->dts_ref_dts_delta = INT_MIN;
 
502
        s->pts_dts_delta     = INT_MIN;
 
503
    }
 
504
 
 
505
    if (s->flags & PARSER_FLAG_ONCE) {
 
506
        s->flags &= PARSER_FLAG_COMPLETE_FRAMES;
 
507
    }
 
508
 
 
509
    *poutbuf      = buf;
278
510
    *poutbuf_size = buf_size;
279
511
    return next;
280
512
}
284
516
{
285
517
    int i;
286
518
    uint32_t state = -1;
287
 
    int has_sps= 0;
 
519
    int has_sps    = 0;
288
520
 
289
 
    for(i=0; i<=buf_size; i++){
290
 
        if((state&0xFFFFFF1F) == 0x107)
291
 
            has_sps=1;
292
 
/*        if((state&0xFFFFFF1F) == 0x101 || (state&0xFFFFFF1F) == 0x102 || (state&0xFFFFFF1F) == 0x105){
293
 
        }*/
294
 
        if((state&0xFFFFFF00) == 0x100 && (state&0xFFFFFF1F) != 0x107 && (state&0xFFFFFF1F) != 0x108 && (state&0xFFFFFF1F) != 0x109){
295
 
            if(has_sps){
296
 
                while(i>4 && buf[i-5]==0) i--;
297
 
                return i-4;
 
521
    for (i = 0; i <= buf_size; i++) {
 
522
        if ((state & 0xFFFFFF1F) == 0x107)
 
523
            has_sps = 1;
 
524
        /*  if ((state&0xFFFFFF1F) == 0x101 ||
 
525
         *     (state&0xFFFFFF1F) == 0x102 ||
 
526
         *     (state&0xFFFFFF1F) == 0x105) {
 
527
         *  }
 
528
         */
 
529
        if ((state & 0xFFFFFF00) == 0x100 && (state & 0xFFFFFF1F) != 0x107 &&
 
530
            (state & 0xFFFFFF1F) != 0x108 && (state & 0xFFFFFF1F) != 0x109) {
 
531
            if (has_sps) {
 
532
                while (i > 4 && buf[i - 5] == 0)
 
533
                    i--;
 
534
                return i - 4;
298
535
            }
299
536
        }
300
 
        if (i<buf_size)
301
 
            state= (state<<8) | buf[i];
 
537
        if (i < buf_size)
 
538
            state = (state << 8) | buf[i];
302
539
    }
303
540
    return 0;
304
541
}
305
542
 
306
543
static void close(AVCodecParserContext *s)
307
544
{
308
 
    H264Context *h = s->priv_data;
309
 
    ParseContext *pc = &h->s.parse_context;
 
545
    H264Context *h   = s->priv_data;
 
546
    ParseContext *pc = &h->parse_context;
310
547
 
311
548
    av_free(pc->buffer);
312
549
    ff_h264_free_context(h);
313
550
}
314
551
 
315
 
static int init(AVCodecParserContext *s)
 
552
static av_cold int init(AVCodecParserContext *s)
316
553
{
317
554
    H264Context *h = s->priv_data;
318
 
    h->thread_context[0] = h;
 
555
    h->thread_context[0]   = h;
 
556
    h->slice_context_count = 1;
 
557
    ff_h264dsp_init(&h->h264dsp, 8, 1);
319
558
    return 0;
320
559
}
321
560
 
322
 
AVCodecParser h264_parser = {
323
 
    { CODEC_ID_H264 },
324
 
    sizeof(H264Context),
325
 
    init,
326
 
    h264_parse,
327
 
    close,
328
 
    h264_split,
 
561
AVCodecParser ff_h264_parser = {
 
562
    .codec_ids      = { AV_CODEC_ID_H264 },
 
563
    .priv_data_size = sizeof(H264Context),
 
564
    .parser_init    = init,
 
565
    .parser_parse   = h264_parse,
 
566
    .parser_close   = close,
 
567
    .split          = h264_split,
329
568
};