Mercurial > libavcodec.hg
annotate parser.c @ 10893:2aafcafbe1f0 libavcodec
Replace cabac checks in inline functions from h264.h with constants.
No benchmark because its just replacing variables with litteral constants
(so no risk for slowdown outside gcc silliness) and i need sleep.
author | michael |
---|---|
date | Sat, 16 Jan 2010 05:41:33 +0000 |
parents | 05a510cd1e3b |
children | b94e1810ce4c |
rev | line source |
---|---|
1613 | 1 /* |
2 * Audio and Video frame extraction | |
8629
04423b2f6e0b
cosmetics: Remove pointless period after copyright statement non-sentences.
diego
parents:
8044
diff
changeset
|
3 * Copyright (c) 2003 Fabrice Bellard |
04423b2f6e0b
cosmetics: Remove pointless period after copyright statement non-sentences.
diego
parents:
8044
diff
changeset
|
4 * Copyright (c) 2003 Michael Niedermayer |
1613 | 5 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3776
diff
changeset
|
6 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3776
diff
changeset
|
7 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3776
diff
changeset
|
8 * FFmpeg is free software; you can redistribute it and/or |
1613 | 9 * modify it under the terms of the GNU Lesser General Public |
10 * License as published by the Free Software Foundation; either | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3776
diff
changeset
|
11 * version 2.1 of the License, or (at your option) any later version. |
1613 | 12 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3776
diff
changeset
|
13 * FFmpeg is distributed in the hope that it will be useful, |
1613 | 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
16 * Lesser General Public License for more details. | |
17 * | |
18 * You should have received a copy of the GNU Lesser General Public | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3776
diff
changeset
|
19 * License along with FFmpeg; if not, write to the Free Software |
3036
0b546eab515d
Update licensing information: The FSF changed postal address.
diego
parents:
2979
diff
changeset
|
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
1613 | 21 */ |
4943 | 22 |
4150
2205aefb22b7
move AVCodecParser prototypes and definitions to parser.h, and move mpegvideo parser to mpeg12.c
bcoudurier
parents:
4146
diff
changeset
|
23 #include "parser.h" |
1613 | 24 |
7992 | 25 static AVCodecParser *av_first_parser = NULL; |
1613 | 26 |
6011 | 27 AVCodecParser* av_parser_next(AVCodecParser *p){ |
28 if(p) return p->next; | |
29 else return av_first_parser; | |
30 } | |
31 | |
1613 | 32 void av_register_codec_parser(AVCodecParser *parser) |
33 { | |
34 parser->next = av_first_parser; | |
35 av_first_parser = parser; | |
36 } | |
37 | |
38 AVCodecParserContext *av_parser_init(int codec_id) | |
39 { | |
40 AVCodecParserContext *s; | |
41 AVCodecParser *parser; | |
42 int ret; | |
2967 | 43 |
2486
f2a9559db6ac
10l (array gets padded with 0 which is CODEC_ID_NONE -> parsers claim to support CODEC_ID_NONE)
michael
parents:
2480
diff
changeset
|
44 if(codec_id == CODEC_ID_NONE) |
f2a9559db6ac
10l (array gets padded with 0 which is CODEC_ID_NONE -> parsers claim to support CODEC_ID_NONE)
michael
parents:
2480
diff
changeset
|
45 return NULL; |
1613 | 46 |
47 for(parser = av_first_parser; parser != NULL; parser = parser->next) { | |
48 if (parser->codec_ids[0] == codec_id || | |
49 parser->codec_ids[1] == codec_id || | |
2348 | 50 parser->codec_ids[2] == codec_id || |
51 parser->codec_ids[3] == codec_id || | |
52 parser->codec_ids[4] == codec_id) | |
1613 | 53 goto found; |
54 } | |
55 return NULL; | |
56 found: | |
57 s = av_mallocz(sizeof(AVCodecParserContext)); | |
58 if (!s) | |
59 return NULL; | |
60 s->parser = parser; | |
61 s->priv_data = av_mallocz(parser->priv_data_size); | |
62 if (!s->priv_data) { | |
63 av_free(s); | |
64 return NULL; | |
65 } | |
66 if (parser->parser_init) { | |
67 ret = parser->parser_init(s); | |
68 if (ret != 0) { | |
69 av_free(s->priv_data); | |
70 av_free(s); | |
71 return NULL; | |
72 } | |
73 } | |
2030 | 74 s->fetch_timestamp=1; |
4739
9b4c5d2fb8ce
set pict_type to I type during init so parsers which dont set it get all i frames, fixes mp3 seeking
michael
parents:
4679
diff
changeset
|
75 s->pict_type = FF_I_TYPE; |
8973
34f2c7189710
Add key_frame to AVCodecParserContext, used in libavformat.
cehoyos
parents:
8629
diff
changeset
|
76 s->key_frame = -1; |
8989 | 77 s->convergence_duration = AV_NOPTS_VALUE; |
9038
d4c12f2d226b
Add timestamp computation if values are exported by decoder.
cehoyos
parents:
8989
diff
changeset
|
78 s->dts_sync_point = INT_MIN; |
d4c12f2d226b
Add timestamp computation if values are exported by decoder.
cehoyos
parents:
8989
diff
changeset
|
79 s->dts_ref_dts_delta = INT_MIN; |
d4c12f2d226b
Add timestamp computation if values are exported by decoder.
cehoyos
parents:
8989
diff
changeset
|
80 s->pts_dts_delta = INT_MIN; |
1613 | 81 return s; |
82 } | |
83 | |
6985
7c8df4f99d08
Allow matching timestamps to be removed by fetch_timestamp().
michael
parents:
6984
diff
changeset
|
84 void ff_fetch_timestamp(AVCodecParserContext *s, int off, int remove){ |
6983 | 85 int i; |
6986 | 86 |
6983 | 87 s->dts= s->pts= AV_NOPTS_VALUE; |
9140 | 88 s->pos= -1; |
6983 | 89 s->offset= 0; |
90 for(i = 0; i < AV_PARSER_PTS_NB; i++) { | |
9090
cecf81f93756
Call ff_fetch_timestamp() for mpeg1/2 when a picture start code is found instead
michael
parents:
9038
diff
changeset
|
91 if ( s->cur_offset + off >= s->cur_frame_offset[i] |
9878
05a510cd1e3b
Fetch timestamp for the first frame of field only if frame_offset and
bcoudurier
parents:
9717
diff
changeset
|
92 && (s->frame_offset < s->cur_frame_offset[i] || |
05a510cd1e3b
Fetch timestamp for the first frame of field only if frame_offset and
bcoudurier
parents:
9717
diff
changeset
|
93 (!s->frame_offset && !s->next_frame_offset)) // first field/frame |
6988
c67a4cff28a1
Our MPEG-TS demuxer does not send complete PES packets but sends them
michael
parents:
6986
diff
changeset
|
94 //check is disabled becausue mpeg-ts doesnt send complete PES packets |
c67a4cff28a1
Our MPEG-TS demuxer does not send complete PES packets but sends them
michael
parents:
6986
diff
changeset
|
95 && /*s->next_frame_offset + off <*/ s->cur_frame_end[i]){ |
6983 | 96 s->dts= s->cur_frame_dts[i]; |
97 s->pts= s->cur_frame_pts[i]; | |
9140 | 98 s->pos= s->cur_frame_pos[i]; |
6983 | 99 s->offset = s->next_frame_offset - s->cur_frame_offset[i]; |
6985
7c8df4f99d08
Allow matching timestamps to be removed by fetch_timestamp().
michael
parents:
6984
diff
changeset
|
100 if(remove) |
7c8df4f99d08
Allow matching timestamps to be removed by fetch_timestamp().
michael
parents:
6984
diff
changeset
|
101 s->cur_frame_offset[i]= INT64_MAX; |
9091
4875c1559060
Favor container packets that end after the first byte of the access
michael
parents:
9090
diff
changeset
|
102 if(s->cur_offset + off < s->cur_frame_end[i]) |
4875c1559060
Favor container packets that end after the first byte of the access
michael
parents:
9090
diff
changeset
|
103 break; |
6983 | 104 } |
105 } | |
106 } | |
107 | |
3989 | 108 /** |
109 * | |
110 * @param buf input | |
111 * @param buf_size input length, to signal EOF, this should be 0 (so that the last frame can be output) | |
112 * @param pts input presentation timestamp | |
113 * @param dts input decoding timestamp | |
114 * @param poutbuf will contain a pointer to the first byte of the output frame | |
115 * @param poutbuf_size will contain the length of the output frame | |
116 * @return the number of bytes of the input bitstream used | |
117 * | |
118 * Example: | |
119 * @code | |
120 * while(in_len){ | |
121 * len = av_parser_parse(myparser, AVCodecContext, &data, &size, | |
122 * in_data, in_len, | |
123 * pts, dts); | |
124 * in_data += len; | |
125 * in_len -= len; | |
126 * | |
4310 | 127 * if(size) |
128 * decode_frame(data, size); | |
3989 | 129 * } |
130 * @endcode | |
9140 | 131 * |
132 * @deprecated Use av_parser_parse2() instead. | |
3989 | 133 */ |
2967 | 134 int av_parser_parse(AVCodecParserContext *s, |
1613 | 135 AVCodecContext *avctx, |
2967 | 136 uint8_t **poutbuf, int *poutbuf_size, |
1696 | 137 const uint8_t *buf, int buf_size, |
138 int64_t pts, int64_t dts) | |
1613 | 139 { |
9140 | 140 return av_parser_parse2(s, avctx, poutbuf, poutbuf_size, buf, buf_size, pts, dts, AV_NOPTS_VALUE); |
141 } | |
142 | |
143 int av_parser_parse2(AVCodecParserContext *s, | |
144 AVCodecContext *avctx, | |
145 uint8_t **poutbuf, int *poutbuf_size, | |
146 const uint8_t *buf, int buf_size, | |
147 int64_t pts, int64_t dts, | |
148 int64_t pos) | |
149 { | |
6982 | 150 int index, i; |
1694
13169235c306
added End Of File handling to return last picture for MPEG1/2/4
bellard
parents:
1681
diff
changeset
|
151 uint8_t dummy_buf[FF_INPUT_BUFFER_PADDING_SIZE]; |
2967 | 152 |
1694
13169235c306
added End Of File handling to return last picture for MPEG1/2/4
bellard
parents:
1681
diff
changeset
|
153 if (buf_size == 0) { |
13169235c306
added End Of File handling to return last picture for MPEG1/2/4
bellard
parents:
1681
diff
changeset
|
154 /* padding is always necessary even if EOF, so we add it here */ |
13169235c306
added End Of File handling to return last picture for MPEG1/2/4
bellard
parents:
1681
diff
changeset
|
155 memset(dummy_buf, 0, sizeof(dummy_buf)); |
13169235c306
added End Of File handling to return last picture for MPEG1/2/4
bellard
parents:
1681
diff
changeset
|
156 buf = dummy_buf; |
9717
5ebac9debadf
do not reference remainder packets in the parser, fix timestamps fetching
bcoudurier
parents:
9140
diff
changeset
|
157 } else if (s->cur_offset + buf_size != |
5ebac9debadf
do not reference remainder packets in the parser, fix timestamps fetching
bcoudurier
parents:
9140
diff
changeset
|
158 s->cur_frame_end[s->cur_frame_start_index]) { /* skip remainder packets */ |
1696 | 159 /* add a new packet descriptor */ |
6990 | 160 i = (s->cur_frame_start_index + 1) & (AV_PARSER_PTS_NB - 1); |
161 s->cur_frame_start_index = i; | |
162 s->cur_frame_offset[i] = s->cur_offset; | |
163 s->cur_frame_end[i] = s->cur_offset + buf_size; | |
164 s->cur_frame_pts[i] = pts; | |
165 s->cur_frame_dts[i] = dts; | |
9140 | 166 s->cur_frame_pos[i] = pos; |
6977 | 167 } |
1696 | 168 |
6980 | 169 if (s->fetch_timestamp){ |
170 s->fetch_timestamp=0; | |
6977 | 171 s->last_pts = s->pts; |
172 s->last_dts = s->dts; | |
9140 | 173 s->last_pos = s->pos; |
6985
7c8df4f99d08
Allow matching timestamps to be removed by fetch_timestamp().
michael
parents:
6984
diff
changeset
|
174 ff_fetch_timestamp(s, 0, 0); |
1694
13169235c306
added End Of File handling to return last picture for MPEG1/2/4
bellard
parents:
1681
diff
changeset
|
175 } |
13169235c306
added End Of File handling to return last picture for MPEG1/2/4
bellard
parents:
1681
diff
changeset
|
176 |
1613 | 177 /* WARNING: the returned index can be negative */ |
4931
0d1cc37d9430
make some parser parameters const to avoid casting const to non-const
aurel
parents:
4913
diff
changeset
|
178 index = s->parser->parser_parse(s, avctx, (const uint8_t **)poutbuf, poutbuf_size, buf, buf_size); |
4122
daae66c03857
Replace most of the %lld and %llx by their (cleaner) PRI*64 counterparts.
diego
parents:
4104
diff
changeset
|
179 //av_log(NULL, AV_LOG_DEBUG, "parser: in:%"PRId64", %"PRId64", out:%"PRId64", %"PRId64", in:%d out:%d id:%d\n", pts, dts, s->last_pts, s->last_dts, buf_size, *poutbuf_size, avctx->codec_id); |
1613 | 180 /* update the file pointer */ |
181 if (*poutbuf_size) { | |
1696 | 182 /* fill the data for the current frame */ |
6979 | 183 s->frame_offset = s->next_frame_offset; |
2967 | 184 |
1696 | 185 /* offset of the next frame */ |
6979 | 186 s->next_frame_offset = s->cur_offset + index; |
6980 | 187 s->fetch_timestamp=1; |
1613 | 188 } |
189 if (index < 0) | |
190 index = 0; | |
191 s->cur_offset += index; | |
192 return index; | |
193 } | |
194 | |
2777 | 195 /** |
196 * | |
197 * @return 0 if the output buffer is a subset of the input, 1 if it is allocated and must be freed | |
3421
b7826511f7b6
AVBitStreamFilter (some thingy which can modify the bitstream like add or remove global headers or change the headers or ...)
michael
parents:
3395
diff
changeset
|
198 * @deprecated use AVBitstreamFilter |
2777 | 199 */ |
2769
1394b45a7bf4
support changing in bitstream global headers into extradata style and back
michael
parents:
2637
diff
changeset
|
200 int av_parser_change(AVCodecParserContext *s, |
1394b45a7bf4
support changing in bitstream global headers into extradata style and back
michael
parents:
2637
diff
changeset
|
201 AVCodecContext *avctx, |
2967 | 202 uint8_t **poutbuf, int *poutbuf_size, |
2769
1394b45a7bf4
support changing in bitstream global headers into extradata style and back
michael
parents:
2637
diff
changeset
|
203 const uint8_t *buf, int buf_size, int keyframe){ |
2967 | 204 |
2769
1394b45a7bf4
support changing in bitstream global headers into extradata style and back
michael
parents:
2637
diff
changeset
|
205 if(s && s->parser->split){ |
2777 | 206 if((avctx->flags & CODEC_FLAG_GLOBAL_HEADER) || (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER)){ |
2769
1394b45a7bf4
support changing in bitstream global headers into extradata style and back
michael
parents:
2637
diff
changeset
|
207 int i= s->parser->split(avctx, buf, buf_size); |
1394b45a7bf4
support changing in bitstream global headers into extradata style and back
michael
parents:
2637
diff
changeset
|
208 buf += i; |
1394b45a7bf4
support changing in bitstream global headers into extradata style and back
michael
parents:
2637
diff
changeset
|
209 buf_size -= i; |
1394b45a7bf4
support changing in bitstream global headers into extradata style and back
michael
parents:
2637
diff
changeset
|
210 } |
1394b45a7bf4
support changing in bitstream global headers into extradata style and back
michael
parents:
2637
diff
changeset
|
211 } |
1394b45a7bf4
support changing in bitstream global headers into extradata style and back
michael
parents:
2637
diff
changeset
|
212 |
2864
95bac7109ff0
Kill some compiler warnings. Compiled code verified identical after changes.
mru
parents:
2846
diff
changeset
|
213 /* cast to avoid warning about discarding qualifiers */ |
95bac7109ff0
Kill some compiler warnings. Compiled code verified identical after changes.
mru
parents:
2846
diff
changeset
|
214 *poutbuf= (uint8_t *) buf; |
2769
1394b45a7bf4
support changing in bitstream global headers into extradata style and back
michael
parents:
2637
diff
changeset
|
215 *poutbuf_size= buf_size; |
1394b45a7bf4
support changing in bitstream global headers into extradata style and back
michael
parents:
2637
diff
changeset
|
216 if(avctx->extradata){ |
1394b45a7bf4
support changing in bitstream global headers into extradata style and back
michael
parents:
2637
diff
changeset
|
217 if( (keyframe && (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER)) |
6481 | 218 /*||(s->pict_type != FF_I_TYPE && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_NOKEY))*/ |
2769
1394b45a7bf4
support changing in bitstream global headers into extradata style and back
michael
parents:
2637
diff
changeset
|
219 /*||(? && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_BEGIN)*/){ |
1394b45a7bf4
support changing in bitstream global headers into extradata style and back
michael
parents:
2637
diff
changeset
|
220 int size= buf_size + avctx->extradata_size; |
1394b45a7bf4
support changing in bitstream global headers into extradata style and back
michael
parents:
2637
diff
changeset
|
221 *poutbuf_size= size; |
1394b45a7bf4
support changing in bitstream global headers into extradata style and back
michael
parents:
2637
diff
changeset
|
222 *poutbuf= av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE); |
2967 | 223 |
2769
1394b45a7bf4
support changing in bitstream global headers into extradata style and back
michael
parents:
2637
diff
changeset
|
224 memcpy(*poutbuf, avctx->extradata, avctx->extradata_size); |
2777 | 225 memcpy((*poutbuf) + avctx->extradata_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE); |
2769
1394b45a7bf4
support changing in bitstream global headers into extradata style and back
michael
parents:
2637
diff
changeset
|
226 return 1; |
1394b45a7bf4
support changing in bitstream global headers into extradata style and back
michael
parents:
2637
diff
changeset
|
227 } |
1394b45a7bf4
support changing in bitstream global headers into extradata style and back
michael
parents:
2637
diff
changeset
|
228 } |
1394b45a7bf4
support changing in bitstream global headers into extradata style and back
michael
parents:
2637
diff
changeset
|
229 |
1394b45a7bf4
support changing in bitstream global headers into extradata style and back
michael
parents:
2637
diff
changeset
|
230 return 0; |
1394b45a7bf4
support changing in bitstream global headers into extradata style and back
michael
parents:
2637
diff
changeset
|
231 } |
1394b45a7bf4
support changing in bitstream global headers into extradata style and back
michael
parents:
2637
diff
changeset
|
232 |
1613 | 233 void av_parser_close(AVCodecParserContext *s) |
234 { | |
6891 | 235 if(s){ |
6892 | 236 if (s->parser->parser_close) |
237 s->parser->parser_close(s); | |
238 av_free(s->priv_data); | |
239 av_free(s); | |
6891 | 240 } |
1613 | 241 } |
242 | |
243 /*****************************************************/ | |
244 | |
245 /** | |
246 * combines the (truncated) bitstream to a complete frame | |
6534 | 247 * @returns -1 if no complete frame could be created, AVERROR(ENOMEM) if there was a memory allocation error |
1613 | 248 */ |
4931
0d1cc37d9430
make some parser parameters const to avoid casting const to non-const
aurel
parents:
4913
diff
changeset
|
249 int ff_combine_frame(ParseContext *pc, int next, const uint8_t **buf, int *buf_size) |
1613 | 250 { |
251 #if 0 | |
252 if(pc->overread){ | |
253 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index); | |
254 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]); | |
255 } | |
256 #endif | |
257 | |
4795 | 258 /* Copy overread bytes from last frame into buffer. */ |
1613 | 259 for(; pc->overread>0; pc->overread--){ |
260 pc->buffer[pc->index++]= pc->buffer[pc->overread_index++]; | |
261 } | |
2386 | 262 |
263 /* flush remaining if EOF */ | |
264 if(!*buf_size && next == END_NOT_FOUND){ | |
265 next= 0; | |
266 } | |
267 | |
1613 | 268 pc->last_index= pc->index; |
269 | |
270 /* copy into buffer end return */ | |
271 if(next == END_NOT_FOUND){ | |
6534 | 272 void* new_buffer = av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE); |
1613 | 273 |
6534 | 274 if(!new_buffer) |
275 return AVERROR(ENOMEM); | |
276 pc->buffer = new_buffer; | |
1613 | 277 memcpy(&pc->buffer[pc->index], *buf, *buf_size); |
278 pc->index += *buf_size; | |
279 return -1; | |
280 } | |
281 | |
282 *buf_size= | |
283 pc->overread_index= pc->index + next; | |
2967 | 284 |
1613 | 285 /* append to buffer */ |
286 if(pc->index){ | |
6534 | 287 void* new_buffer = av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE); |
1613 | 288 |
6534 | 289 if(!new_buffer) |
290 return AVERROR(ENOMEM); | |
291 pc->buffer = new_buffer; | |
1613 | 292 memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE ); |
293 pc->index = 0; | |
294 *buf= pc->buffer; | |
295 } | |
296 | |
297 /* store overread bytes */ | |
298 for(;next < 0; next++){ | |
299 pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next]; | |
8044
8c1e1047ec78
add state64 field to ParseContext storing last 8 bytes, to be able to check for longer startcodes
bcoudurier
parents:
8040
diff
changeset
|
300 pc->state64 = (pc->state64<<8) | pc->buffer[pc->last_index + next]; |
1613 | 301 pc->overread++; |
302 } | |
303 | |
304 #if 0 | |
305 if(pc->overread){ | |
306 printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index); | |
307 printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]); | |
308 } | |
309 #endif | |
310 | |
311 return 0; | |
312 } | |
313 | |
1988 | 314 void ff_parse_close(AVCodecParserContext *s) |
1613 | 315 { |
1988 | 316 ParseContext *pc = s->priv_data; |
1613 | 317 |
8040 | 318 av_freep(&pc->buffer); |
1988 | 319 } |
320 | |
4150
2205aefb22b7
move AVCodecParser prototypes and definitions to parser.h, and move mpegvideo parser to mpeg12.c
bcoudurier
parents:
4146
diff
changeset
|
321 void ff_parse1_close(AVCodecParserContext *s) |
1988 | 322 { |
323 ParseContext1 *pc1 = s->priv_data; | |
324 | |
325 av_free(pc1->pc.buffer); | |
326 av_free(pc1->enc); | |
1613 | 327 } |
328 | |
329 /*************************/ | |
330 | |
4175
b3328ed50a5e
make mpeg4video_split public as ff_mpeg4video_split
stefang
parents:
4150
diff
changeset
|
331 int ff_mpeg4video_split(AVCodecContext *avctx, |
2769
1394b45a7bf4
support changing in bitstream global headers into extradata style and back
michael
parents:
2637
diff
changeset
|
332 const uint8_t *buf, int buf_size) |
1394b45a7bf4
support changing in bitstream global headers into extradata style and back
michael
parents:
2637
diff
changeset
|
333 { |
1394b45a7bf4
support changing in bitstream global headers into extradata style and back
michael
parents:
2637
diff
changeset
|
334 int i; |
1394b45a7bf4
support changing in bitstream global headers into extradata style and back
michael
parents:
2637
diff
changeset
|
335 uint32_t state= -1; |
2967 | 336 |
2769
1394b45a7bf4
support changing in bitstream global headers into extradata style and back
michael
parents:
2637
diff
changeset
|
337 for(i=0; i<buf_size; i++){ |
1394b45a7bf4
support changing in bitstream global headers into extradata style and back
michael
parents:
2637
diff
changeset
|
338 state= (state<<8) | buf[i]; |
1394b45a7bf4
support changing in bitstream global headers into extradata style and back
michael
parents:
2637
diff
changeset
|
339 if(state == 0x1B3 || state == 0x1B6) |
2777 | 340 return i-3; |
2769
1394b45a7bf4
support changing in bitstream global headers into extradata style and back
michael
parents:
2637
diff
changeset
|
341 } |
1394b45a7bf4
support changing in bitstream global headers into extradata style and back
michael
parents:
2637
diff
changeset
|
342 return 0; |
1394b45a7bf4
support changing in bitstream global headers into extradata style and back
michael
parents:
2637
diff
changeset
|
343 } |