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 <inttypes.h> 24#include <stdint.h> 25#include <string.h> 26 27#include "libavutil/avassert.h" 28#include "libavutil/mem.h" 29 30#include "parser.h" 31 32AVCodecParserContext *av_parser_init(int codec_id) 33{ 34 AVCodecParserContext *s = NULL; 35 const AVCodecParser *parser; 36 void *i = 0; 37 int ret; 38 39 if (codec_id == AV_CODEC_ID_NONE) 40 return NULL; 41 42 while ((parser = av_parser_iterate(&i))) { 43 if (parser->codec_ids[0] == codec_id || 44 parser->codec_ids[1] == codec_id || 45 parser->codec_ids[2] == codec_id || 46 parser->codec_ids[3] == codec_id || 47 parser->codec_ids[4] == codec_id || 48 parser->codec_ids[5] == codec_id || 49 parser->codec_ids[6] == codec_id) 50 goto found; 51 } 52 return NULL; 53 54found: 55 s = av_mallocz(sizeof(AVCodecParserContext)); 56 if (!s) 57 goto err_out; 58 s->parser = parser; 59 s->priv_data = av_mallocz(parser->priv_data_size); 60 if (!s->priv_data) 61 goto err_out; 62 s->fetch_timestamp=1; 63 s->pict_type = AV_PICTURE_TYPE_I; 64 if (parser->parser_init) { 65 ret = parser->parser_init(s); 66 if (ret != 0) 67 goto err_out; 68 } 69 s->key_frame = -1; 70 s->dts_sync_point = INT_MIN; 71 s->dts_ref_dts_delta = INT_MIN; 72 s->pts_dts_delta = INT_MIN; 73 s->format = -1; 74 75 return s; 76 77err_out: 78 if (s) 79 av_freep(&s->priv_data); 80 av_free(s); 81 return NULL; 82} 83 84void ff_fetch_timestamp(AVCodecParserContext *s, int off, int remove, int fuzzy) 85{ 86 int i; 87 88 if (!fuzzy) { 89 s->dts = 90 s->pts = AV_NOPTS_VALUE; 91 s->pos = -1; 92 s->offset = 0; 93 } 94 for (i = 0; i < AV_PARSER_PTS_NB; i++) { 95 if (s->cur_offset + off >= s->cur_frame_offset[i] && 96 (s->frame_offset < s->cur_frame_offset[i] || 97 (!s->frame_offset && !s->next_frame_offset)) && // first field/frame 98 // check disabled since MPEG-TS does not send complete PES packets 99 /*s->next_frame_offset + off <*/ s->cur_frame_end[i]){ 100 101 if (!fuzzy || s->cur_frame_dts[i] != AV_NOPTS_VALUE) { 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 } 107 if (remove) 108 s->cur_frame_offset[i] = INT64_MAX; 109 if (s->cur_offset + off < s->cur_frame_end[i]) 110 break; 111 } 112 } 113} 114 115int av_parser_parse2(AVCodecParserContext *s, AVCodecContext *avctx, 116 uint8_t **poutbuf, int *poutbuf_size, 117 const uint8_t *buf, int buf_size, 118 int64_t pts, int64_t dts, int64_t pos) 119{ 120 int index, i; 121 uint8_t dummy_buf[AV_INPUT_BUFFER_PADDING_SIZE]; 122 123 av_assert1(avctx->codec_id != AV_CODEC_ID_NONE); 124 125 /* Parsers only work for the specified codec ids. */ 126 av_assert1(avctx->codec_id == s->parser->codec_ids[0] || 127 avctx->codec_id == s->parser->codec_ids[1] || 128 avctx->codec_id == s->parser->codec_ids[2] || 129 avctx->codec_id == s->parser->codec_ids[3] || 130 avctx->codec_id == s->parser->codec_ids[4] || 131 avctx->codec_id == s->parser->codec_ids[5] || 132 avctx->codec_id == s->parser->codec_ids[6]); 133 134 if (!(s->flags & PARSER_FLAG_FETCHED_OFFSET)) { 135 s->next_frame_offset = 136 s->cur_offset = pos; 137 s->flags |= PARSER_FLAG_FETCHED_OFFSET; 138 } 139 140 if (buf_size == 0) { 141 /* padding is always necessary even if EOF, so we add it here */ 142 memset(dummy_buf, 0, sizeof(dummy_buf)); 143 buf = dummy_buf; 144 } else if (s->cur_offset + buf_size != s->cur_frame_end[s->cur_frame_start_index]) { /* skip remainder packets */ 145 /* add a new packet descriptor */ 146 i = (s->cur_frame_start_index + 1) & (AV_PARSER_PTS_NB - 1); 147 s->cur_frame_start_index = i; 148 s->cur_frame_offset[i] = s->cur_offset; 149 s->cur_frame_end[i] = s->cur_offset + buf_size; 150 s->cur_frame_pts[i] = pts; 151 s->cur_frame_dts[i] = dts; 152 s->cur_frame_pos[i] = pos; 153 } 154 155 if (s->fetch_timestamp) { 156 s->fetch_timestamp = 0; 157 s->last_pts = s->pts; 158 s->last_dts = s->dts; 159 s->last_pos = s->pos; 160 ff_fetch_timestamp(s, 0, 0, 0); 161 } 162 /* WARNING: the returned index can be negative */ 163 index = s->parser->parser_parse(s, avctx, (const uint8_t **) poutbuf, 164 poutbuf_size, buf, buf_size); 165 av_assert0(index > -0x20000000); // The API does not allow returning AVERROR codes 166#define FILL(name) if(s->name > 0 && avctx->name <= 0) avctx->name = s->name 167 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) { 168 FILL(field_order); 169 } 170 171 /* update the file pointer */ 172 if (*poutbuf_size) { 173 /* fill the data for the current frame */ 174 s->frame_offset = s->next_frame_offset; 175 176 /* offset of the next frame */ 177 s->next_frame_offset = s->cur_offset + index; 178 s->fetch_timestamp = 1; 179 } else { 180 /* Don't return a pointer to dummy_buf. */ 181 *poutbuf = NULL; 182 } 183 if (index < 0) 184 index = 0; 185 s->cur_offset += index; 186 return index; 187} 188 189void av_parser_close(AVCodecParserContext *s) 190{ 191 if (s) { 192 if (s->parser->parser_close) 193 s->parser->parser_close(s); 194 av_freep(&s->priv_data); 195 av_free(s); 196 } 197} 198 199int ff_combine_frame(ParseContext *pc, int next, 200 const uint8_t **buf, int *buf_size) 201{ 202 if (pc->overread) { 203 ff_dlog(NULL, "overread %d, state:%"PRIX32" next:%d index:%d o_index:%d\n", 204 pc->overread, pc->state, next, pc->index, pc->overread_index); 205 ff_dlog(NULL, "%X %X %X %X\n", 206 (*buf)[0], (*buf)[1], (*buf)[2], (*buf)[3]); 207 } 208 209 /* Copy overread bytes from last frame into buffer. */ 210 for (; pc->overread > 0; pc->overread--) 211 pc->buffer[pc->index++] = pc->buffer[pc->overread_index++]; 212 213 if (next > *buf_size) 214 return AVERROR(EINVAL); 215 216 /* flush remaining if EOF */ 217 if (!*buf_size && next == END_NOT_FOUND) 218 next = 0; 219 220 pc->last_index = pc->index; 221 222 /* copy into buffer end return */ 223 if (next == END_NOT_FOUND) { 224 void *new_buffer = av_fast_realloc(pc->buffer, &pc->buffer_size, 225 *buf_size + pc->index + 226 AV_INPUT_BUFFER_PADDING_SIZE); 227 228 if (!new_buffer) { 229 av_log(NULL, AV_LOG_ERROR, "Failed to reallocate parser buffer to %d\n", *buf_size + pc->index + AV_INPUT_BUFFER_PADDING_SIZE); 230 pc->index = 0; 231 return AVERROR(ENOMEM); 232 } 233 pc->buffer = new_buffer; 234 memcpy(&pc->buffer[pc->index], *buf, *buf_size); 235 memset(&pc->buffer[pc->index + *buf_size], 0, AV_INPUT_BUFFER_PADDING_SIZE); 236 pc->index += *buf_size; 237 return -1; 238 } 239 240 av_assert0(next >= 0 || pc->buffer); 241 242 *buf_size = 243 pc->overread_index = pc->index + next; 244 245 /* append to buffer */ 246 if (pc->index) { 247 void *new_buffer = av_fast_realloc(pc->buffer, &pc->buffer_size, 248 next + pc->index + 249 AV_INPUT_BUFFER_PADDING_SIZE); 250 if (!new_buffer) { 251 av_log(NULL, AV_LOG_ERROR, "Failed to reallocate parser buffer to %d\n", next + pc->index + AV_INPUT_BUFFER_PADDING_SIZE); 252 pc->overread_index = 253 pc->index = 0; 254 return AVERROR(ENOMEM); 255 } 256 pc->buffer = new_buffer; 257 if (next > -AV_INPUT_BUFFER_PADDING_SIZE) 258 memcpy(&pc->buffer[pc->index], *buf, 259 next + AV_INPUT_BUFFER_PADDING_SIZE); 260 pc->index = 0; 261 *buf = pc->buffer; 262 } 263 264 if (next < -8) { 265 pc->overread += -8 - next; 266 next = -8; 267 } 268 /* store overread bytes */ 269 for (; next < 0; next++) { 270 pc->state = pc->state << 8 | pc->buffer[pc->last_index + next]; 271 pc->state64 = pc->state64 << 8 | pc->buffer[pc->last_index + next]; 272 pc->overread++; 273 } 274 275 if (pc->overread) { 276 ff_dlog(NULL, "overread %d, state:%"PRIX32" next:%d index:%d o_index:%d\n", 277 pc->overread, pc->state, next, pc->index, pc->overread_index); 278 ff_dlog(NULL, "%X %X %X %X\n", 279 (*buf)[0], (*buf)[1], (*buf)[2], (*buf)[3]); 280 } 281 282 return 0; 283} 284 285void ff_parse_close(AVCodecParserContext *s) 286{ 287 ParseContext *pc = s->priv_data; 288 289 av_freep(&pc->buffer); 290} 291