Details | Last modification | View Log | RSS feed
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 6148 | serge | 1 | /* |
| 2 | * Audio and Video frame extraction |
||
| 3 | * Copyright (c) 2003 Fabrice Bellard |
||
| 4 | * Copyright (c) 2003 Michael Niedermayer |
||
| 5 | * |
||
| 6 | * This file is part of FFmpeg. |
||
| 7 | * |
||
| 8 | * FFmpeg is free software; you can redistribute it and/or |
||
| 9 | * modify it under the terms of the GNU Lesser General Public |
||
| 10 | * License as published by the Free Software Foundation; either |
||
| 11 | * version 2.1 of the License, or (at your option) any later version. |
||
| 12 | * |
||
| 13 | * FFmpeg is distributed in the hope that it will be useful, |
||
| 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 |
||
| 19 | * License along with FFmpeg; if not, write to the Free Software |
||
| 20 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
||
| 21 | */ |
||
| 22 | |||
| 23 | #include |
||
| 24 | |||
| 25 | #include "parser.h" |
||
| 26 | #include "libavutil/atomic.h" |
||
| 27 | #include "libavutil/mem.h" |
||
| 28 | |||
| 29 | static AVCodecParser *av_first_parser = NULL; |
||
| 30 | |||
| 31 | AVCodecParser* av_parser_next(AVCodecParser *p){ |
||
| 32 | if(p) return p->next; |
||
| 33 | else return av_first_parser; |
||
| 34 | } |
||
| 35 | |||
| 36 | void av_register_codec_parser(AVCodecParser *parser) |
||
| 37 | { |
||
| 38 | do { |
||
| 39 | parser->next = av_first_parser; |
||
| 40 | } while (parser->next != avpriv_atomic_ptr_cas((void * volatile *)&av_first_parser, parser->next, parser)); |
||
| 41 | } |
||
| 42 | |||
| 43 | AVCodecParserContext *av_parser_init(int codec_id) |
||
| 44 | { |
||
| 45 | AVCodecParserContext *s = NULL; |
||
| 46 | AVCodecParser *parser; |
||
| 47 | int ret; |
||
| 48 | |||
| 49 | if(codec_id == AV_CODEC_ID_NONE) |
||
| 50 | return NULL; |
||
| 51 | |||
| 52 | for(parser = av_first_parser; parser != NULL; parser = parser->next) { |
||
| 53 | if (parser->codec_ids[0] == codec_id || |
||
| 54 | parser->codec_ids[1] == codec_id || |
||
| 55 | parser->codec_ids[2] == codec_id || |
||
| 56 | parser->codec_ids[3] == codec_id || |
||
| 57 | parser->codec_ids[4] == codec_id) |
||
| 58 | goto found; |
||
| 59 | } |
||
| 60 | return NULL; |
||
| 61 | found: |
||
| 62 | s = av_mallocz(sizeof(AVCodecParserContext)); |
||
| 63 | if (!s) |
||
| 64 | goto err_out; |
||
| 65 | s->parser = parser; |
||
| 66 | s->priv_data = av_mallocz(parser->priv_data_size); |
||
| 67 | if (!s->priv_data) |
||
| 68 | goto err_out; |
||
| 69 | s->fetch_timestamp=1; |
||
| 70 | s->pict_type = AV_PICTURE_TYPE_I; |
||
| 71 | if (parser->parser_init) { |
||
| 72 | ret = parser->parser_init(s); |
||
| 73 | if (ret != 0) |
||
| 74 | goto err_out; |
||
| 75 | } |
||
| 76 | s->key_frame = -1; |
||
| 77 | s->convergence_duration = 0; |
||
| 78 | s->dts_sync_point = INT_MIN; |
||
| 79 | s->dts_ref_dts_delta = INT_MIN; |
||
| 80 | s->pts_dts_delta = INT_MIN; |
||
| 81 | return s; |
||
| 82 | |||
| 83 | err_out: |
||
| 84 | if (s) |
||
| 85 | av_freep(&s->priv_data); |
||
| 86 | av_free(s); |
||
| 87 | return NULL; |
||
| 88 | } |
||
| 89 | |||
| 90 | void ff_fetch_timestamp(AVCodecParserContext *s, int off, int remove){ |
||
| 91 | int i; |
||
| 92 | |||
| 93 | s->dts= s->pts= AV_NOPTS_VALUE; |
||
| 94 | s->pos= -1; |
||
| 95 | s->offset= 0; |
||
| 96 | for(i = 0; i < AV_PARSER_PTS_NB; i++) { |
||
| 97 | if ( s->cur_offset + off >= s->cur_frame_offset[i] |
||
| 98 | && (s->frame_offset < s->cur_frame_offset[i] || |
||
| 99 | (!s->frame_offset && !s->next_frame_offset)) // first field/frame |
||
| 100 | // check disabled since MPEG-TS does not send complete PES packets |
||
| 101 | && /*s->next_frame_offset + off <*/ s->cur_frame_end[i]){ |
||
| 102 | s->dts= s->cur_frame_dts[i]; |
||
| 103 | s->pts= s->cur_frame_pts[i]; |
||
| 104 | s->pos= s->cur_frame_pos[i]; |
||
| 105 | s->offset = s->next_frame_offset - s->cur_frame_offset[i]; |
||
| 106 | if(remove) |
||
| 107 | s->cur_frame_offset[i]= INT64_MAX; |
||
| 108 | if(s->cur_offset + off < s->cur_frame_end[i]) |
||
| 109 | break; |
||
| 110 | } |
||
| 111 | } |
||
| 112 | } |
||
| 113 | |||
| 114 | int av_parser_parse2(AVCodecParserContext *s, |
||
| 115 | AVCodecContext *avctx, |
||
| 116 | uint8_t **poutbuf, int *poutbuf_size, |
||
| 117 | const uint8_t *buf, int buf_size, |
||
| 118 | int64_t pts, int64_t dts, |
||
| 119 | int64_t pos) |
||
| 120 | { |
||
| 121 | int index, i; |
||
| 122 | uint8_t dummy_buf[FF_INPUT_BUFFER_PADDING_SIZE]; |
||
| 123 | |||
| 124 | if(!(s->flags & PARSER_FLAG_FETCHED_OFFSET)) { |
||
| 125 | s->next_frame_offset = |
||
| 126 | s->cur_offset = pos; |
||
| 127 | s->flags |= PARSER_FLAG_FETCHED_OFFSET; |
||
| 128 | } |
||
| 129 | |||
| 130 | if (buf_size == 0) { |
||
| 131 | /* padding is always necessary even if EOF, so we add it here */ |
||
| 132 | memset(dummy_buf, 0, sizeof(dummy_buf)); |
||
| 133 | buf = dummy_buf; |
||
| 134 | } else if (s->cur_offset + buf_size != |
||
| 135 | s->cur_frame_end[s->cur_frame_start_index]) { /* skip remainder packets */ |
||
| 136 | /* add a new packet descriptor */ |
||
| 137 | i = (s->cur_frame_start_index + 1) & (AV_PARSER_PTS_NB - 1); |
||
| 138 | s->cur_frame_start_index = i; |
||
| 139 | s->cur_frame_offset[i] = s->cur_offset; |
||
| 140 | s->cur_frame_end[i] = s->cur_offset + buf_size; |
||
| 141 | s->cur_frame_pts[i] = pts; |
||
| 142 | s->cur_frame_dts[i] = dts; |
||
| 143 | s->cur_frame_pos[i] = pos; |
||
| 144 | } |
||
| 145 | |||
| 146 | if (s->fetch_timestamp){ |
||
| 147 | s->fetch_timestamp=0; |
||
| 148 | s->last_pts = s->pts; |
||
| 149 | s->last_dts = s->dts; |
||
| 150 | s->last_pos = s->pos; |
||
| 151 | ff_fetch_timestamp(s, 0, 0); |
||
| 152 | } |
||
| 153 | |||
| 154 | /* WARNING: the returned index can be negative */ |
||
| 155 | index = s->parser->parser_parse(s, avctx, (const uint8_t **)poutbuf, poutbuf_size, buf, buf_size); |
||
| 156 | /* update the file pointer */ |
||
| 157 | if (*poutbuf_size) { |
||
| 158 | /* fill the data for the current frame */ |
||
| 159 | s->frame_offset = s->next_frame_offset; |
||
| 160 | |||
| 161 | /* offset of the next frame */ |
||
| 162 | s->next_frame_offset = s->cur_offset + index; |
||
| 163 | s->fetch_timestamp=1; |
||
| 164 | } |
||
| 165 | if (index < 0) |
||
| 166 | index = 0; |
||
| 167 | s->cur_offset += index; |
||
| 168 | return index; |
||
| 169 | } |
||
| 170 | |||
| 171 | int av_parser_change(AVCodecParserContext *s, |
||
| 172 | AVCodecContext *avctx, |
||
| 173 | uint8_t **poutbuf, int *poutbuf_size, |
||
| 174 | const uint8_t *buf, int buf_size, int keyframe){ |
||
| 175 | |||
| 176 | if(s && s->parser->split){ |
||
| 177 | if((avctx->flags & CODEC_FLAG_GLOBAL_HEADER) || (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER)){ |
||
| 178 | int i= s->parser->split(avctx, buf, buf_size); |
||
| 179 | buf += i; |
||
| 180 | buf_size -= i; |
||
| 181 | } |
||
| 182 | } |
||
| 183 | |||
| 184 | /* cast to avoid warning about discarding qualifiers */ |
||
| 185 | *poutbuf= (uint8_t *) buf; |
||
| 186 | *poutbuf_size= buf_size; |
||
| 187 | if(avctx->extradata){ |
||
| 188 | if( (keyframe && (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER)) |
||
| 189 | /*||(s->pict_type != AV_PICTURE_TYPE_I && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_NOKEY))*/ |
||
| 190 | /*||(? && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_BEGIN)*/){ |
||
| 191 | int size= buf_size + avctx->extradata_size; |
||
| 192 | *poutbuf_size= size; |
||
| 193 | *poutbuf= av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE); |
||
| 194 | |||
| 195 | memcpy(*poutbuf, avctx->extradata, avctx->extradata_size); |
||
| 196 | memcpy((*poutbuf) + avctx->extradata_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE); |
||
| 197 | return 1; |
||
| 198 | } |
||
| 199 | } |
||
| 200 | |||
| 201 | return 0; |
||
| 202 | } |
||
| 203 | |||
| 204 | void av_parser_close(AVCodecParserContext *s) |
||
| 205 | { |
||
| 206 | if(s){ |
||
| 207 | if (s->parser->parser_close) |
||
| 208 | s->parser->parser_close(s); |
||
| 209 | av_free(s->priv_data); |
||
| 210 | av_free(s); |
||
| 211 | } |
||
| 212 | } |
||
| 213 | |||
| 214 | /*****************************************************/ |
||
| 215 | |||
| 216 | int ff_combine_frame(ParseContext *pc, int next, const uint8_t **buf, int *buf_size) |
||
| 217 | { |
||
| 218 | if(pc->overread){ |
||
| 219 | av_dlog(NULL, "overread %d, state:%X next:%d index:%d o_index:%d\n", |
||
| 220 | pc->overread, pc->state, next, pc->index, pc->overread_index); |
||
| 221 | av_dlog(NULL, "%X %X %X %X\n", (*buf)[0], (*buf)[1], (*buf)[2], (*buf)[3]); |
||
| 222 | } |
||
| 223 | |||
| 224 | /* Copy overread bytes from last frame into buffer. */ |
||
| 225 | for(; pc->overread>0; pc->overread--){ |
||
| 226 | pc->buffer[pc->index++]= pc->buffer[pc->overread_index++]; |
||
| 227 | } |
||
| 228 | |||
| 229 | /* flush remaining if EOF */ |
||
| 230 | if(!*buf_size && next == END_NOT_FOUND){ |
||
| 231 | next= 0; |
||
| 232 | } |
||
| 233 | |||
| 234 | pc->last_index= pc->index; |
||
| 235 | |||
| 236 | /* copy into buffer end return */ |
||
| 237 | if(next == END_NOT_FOUND){ |
||
| 238 | void* new_buffer = av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE); |
||
| 239 | |||
| 240 | if(!new_buffer) { |
||
| 241 | pc->index = 0; |
||
| 242 | return AVERROR(ENOMEM); |
||
| 243 | } |
||
| 244 | pc->buffer = new_buffer; |
||
| 245 | memcpy(&pc->buffer[pc->index], *buf, *buf_size); |
||
| 246 | pc->index += *buf_size; |
||
| 247 | return -1; |
||
| 248 | } |
||
| 249 | |||
| 250 | *buf_size= |
||
| 251 | pc->overread_index= pc->index + next; |
||
| 252 | |||
| 253 | /* append to buffer */ |
||
| 254 | if(pc->index){ |
||
| 255 | void* new_buffer = av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE); |
||
| 256 | if(!new_buffer) { |
||
| 257 | pc->overread_index = |
||
| 258 | pc->index = 0; |
||
| 259 | return AVERROR(ENOMEM); |
||
| 260 | } |
||
| 261 | pc->buffer = new_buffer; |
||
| 262 | if (next > -FF_INPUT_BUFFER_PADDING_SIZE) |
||
| 263 | memcpy(&pc->buffer[pc->index], *buf, |
||
| 264 | next + FF_INPUT_BUFFER_PADDING_SIZE); |
||
| 265 | pc->index = 0; |
||
| 266 | *buf= pc->buffer; |
||
| 267 | } |
||
| 268 | |||
| 269 | /* store overread bytes */ |
||
| 270 | for(;next < 0; next++){ |
||
| 271 | pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next]; |
||
| 272 | pc->state64 = (pc->state64<<8) | pc->buffer[pc->last_index + next]; |
||
| 273 | pc->overread++; |
||
| 274 | } |
||
| 275 | |||
| 276 | if(pc->overread){ |
||
| 277 | av_dlog(NULL, "overread %d, state:%X next:%d index:%d o_index:%d\n", |
||
| 278 | pc->overread, pc->state, next, pc->index, pc->overread_index); |
||
| 279 | av_dlog(NULL, "%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]); |
||
| 280 | } |
||
| 281 | |||
| 282 | return 0; |
||
| 283 | } |
||
| 284 | |||
| 285 | void ff_parse_close(AVCodecParserContext *s) |
||
| 286 | { |
||
| 287 | ParseContext *pc = s->priv_data; |
||
| 288 | |||
| 289 | av_freep(&pc->buffer); |
||
| 290 | } |
||
| 291 | |||
| 292 | /*************************/ |
||
| 293 | |||
| 294 | int ff_mpeg4video_split(AVCodecContext *avctx, |
||
| 295 | const uint8_t *buf, int buf_size) |
||
| 296 | { |
||
| 297 | int i; |
||
| 298 | uint32_t state= -1; |
||
| 299 | |||
| 300 | for(i=0; i |
||
| 301 | state= (state<<8) | buf[i]; |
||
| 302 | if(state == 0x1B3 || state == 0x1B6) |
||
| 303 | return i-3; |
||
| 304 | } |
||
| 305 | return 0; |
||
| 306 | } |