git.sesse.net Git - ffmpeg/blob - libavcodec/parser.c

   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 "parser.h"
  24
  25 AVCodecParser *av_first_parser = NULL;
  26
  27 void av_register_codec_parser(AVCodecParser *parser)
  28 {
  29     parser->next = av_first_parser;
  30     av_first_parser = parser;
  31 }
  32
  33 AVCodecParserContext *av_parser_init(int codec_id)
  34 {
  35     AVCodecParserContext *s;
  36     AVCodecParser *parser;
  37     int ret;
  38
  39     if(codec_id == CODEC_ID_NONE)
  40         return NULL;
  41
  42     for(parser = av_first_parser; parser != NULL; parser = parser->next) {
  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             goto found;
  49     }
  50     return NULL;
  51  found:
  52     s = av_mallocz(sizeof(AVCodecParserContext));
  53     if (!s)
  54         return NULL;
  55     s->parser = parser;
  56     s->priv_data = av_mallocz(parser->priv_data_size);
  57     if (!s->priv_data) {
  58         av_free(s);
  59         return NULL;
  60     }
  61     if (parser->parser_init) {
  62         ret = parser->parser_init(s);
  63         if (ret != 0) {
  64             av_free(s->priv_data);
  65             av_free(s);
  66             return NULL;
  67         }
  68     }
  69     s->fetch_timestamp=1;
  70     s->pict_type = FF_I_TYPE;
  71     return s;
  72 }
  73
  74 /**
  75  *
  76  * @param buf           input
  77  * @param buf_size      input length, to signal EOF, this should be 0 (so that the last frame can be output)
  78  * @param pts           input presentation timestamp
  79  * @param dts           input decoding timestamp
  80  * @param poutbuf       will contain a pointer to the first byte of the output frame
  81  * @param poutbuf_size  will contain the length of the output frame
  82  * @return the number of bytes of the input bitstream used
  83  *
  84  * Example:
  85  * @code
  86  *   while(in_len){
  87  *       len = av_parser_parse(myparser, AVCodecContext, &data, &size,
  88  *                                       in_data, in_len,
  89  *                                       pts, dts);
  90  *       in_data += len;
  91  *       in_len  -= len;
  92  *
  93  *       if(size)
  94  *          decode_frame(data, size);
  95  *   }
  96  * @endcode
  97  */
  98 int av_parser_parse(AVCodecParserContext *s,
  99                     AVCodecContext *avctx,
 100                     uint8_t **poutbuf, int *poutbuf_size,
 101                     const uint8_t *buf, int buf_size,
 102                     int64_t pts, int64_t dts)
 103 {
 104     int index, i, k;
 105     uint8_t dummy_buf[FF_INPUT_BUFFER_PADDING_SIZE];
 106
 107     if (buf_size == 0) {
 108         /* padding is always necessary even if EOF, so we add it here */
 109         memset(dummy_buf, 0, sizeof(dummy_buf));
 110         buf = dummy_buf;
 111     } else {
 112         /* add a new packet descriptor */
 113         k = (s->cur_frame_start_index + 1) & (AV_PARSER_PTS_NB - 1);
 114         s->cur_frame_start_index = k;
 115         s->cur_frame_offset[k] = s->cur_offset;
 116         s->cur_frame_pts[k] = pts;
 117         s->cur_frame_dts[k] = dts;
 118
 119         /* fill first PTS/DTS */
 120         if (s->fetch_timestamp){
 121             s->fetch_timestamp=0;
 122             s->last_pts = pts;
 123             s->last_dts = dts;
 124             s->last_offset = 0;
 125             s->cur_frame_pts[k] =
 126             s->cur_frame_dts[k] = AV_NOPTS_VALUE;
 127         }
 128     }
 129
 130     /* WARNING: the returned index can be negative */
 131     index = s->parser->parser_parse(s, avctx, (const uint8_t **)poutbuf, poutbuf_size, buf, buf_size);
 132 //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);
 133     /* update the file pointer */
 134     if (*poutbuf_size) {
 135         /* fill the data for the current frame */
 136         s->frame_offset = s->last_frame_offset;
 137         s->pts = s->last_pts;
 138         s->dts = s->last_dts;
 139         s->offset = s->last_offset;
 140
 141         /* offset of the next frame */
 142         s->last_frame_offset = s->cur_offset + index;
 143         /* find the packet in which the new frame starts. It
 144            is tricky because of MPEG video start codes
 145            which can begin in one packet and finish in
 146            another packet. In the worst case, an MPEG
 147            video start code could be in 4 different
 148            packets. */
 149         k = s->cur_frame_start_index;
 150         for(i = 0; i < AV_PARSER_PTS_NB; i++) {
 151             if (s->last_frame_offset >= s->cur_frame_offset[k])
 152                 break;
 153             k = (k - 1) & (AV_PARSER_PTS_NB - 1);
 154         }
 155
 156         s->last_pts = s->cur_frame_pts[k];
 157         s->last_dts = s->cur_frame_dts[k];
 158         s->last_offset = s->last_frame_offset - s->cur_frame_offset[k];
 159
 160         /* some parsers tell us the packet size even before seeing the first byte of the next packet,
 161            so the next pts/dts is in the next chunk */
 162         if(index == buf_size){
 163             s->fetch_timestamp=1;
 164         }
 165     }
 166     if (index < 0)
 167         index = 0;
 168     s->cur_offset += index;
 169     return index;
 170 }
 171
 172 /**
 173  *
 174  * @return 0 if the output buffer is a subset of the input, 1 if it is allocated and must be freed
 175  * @deprecated use AVBitstreamFilter
 176  */
 177 int av_parser_change(AVCodecParserContext *s,
 178                      AVCodecContext *avctx,
 179                      uint8_t **poutbuf, int *poutbuf_size,
 180                      const uint8_t *buf, int buf_size, int keyframe){
 181
 182     if(s && s->parser->split){
 183         if((avctx->flags & CODEC_FLAG_GLOBAL_HEADER) || (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER)){
 184             int i= s->parser->split(avctx, buf, buf_size);
 185             buf += i;
 186             buf_size -= i;
 187         }
 188     }
 189
 190     /* cast to avoid warning about discarding qualifiers */
 191     *poutbuf= (uint8_t *) buf;
 192     *poutbuf_size= buf_size;
 193     if(avctx->extradata){
 194         if(  (keyframe && (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER))
 195             /*||(s->pict_type != I_TYPE && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_NOKEY))*/
 196             /*||(? && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_BEGIN)*/){
 197             int size= buf_size + avctx->extradata_size;
 198             *poutbuf_size= size;
 199             *poutbuf= av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
 200
 201             memcpy(*poutbuf, avctx->extradata, avctx->extradata_size);
 202             memcpy((*poutbuf) + avctx->extradata_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
 203             return 1;
 204         }
 205     }
 206
 207     return 0;
 208 }
 209
 210 void av_parser_close(AVCodecParserContext *s)
 211 {
 212     if (s->parser->parser_close)
 213         s->parser->parser_close(s);
 214     av_free(s->priv_data);
 215     av_free(s);
 216 }
 217
 218 /*****************************************************/
 219
 220 /**
 221  * combines the (truncated) bitstream to a complete frame
 222  * @returns -1 if no complete frame could be created
 223  */
 224 int ff_combine_frame(ParseContext *pc, int next, const uint8_t **buf, int *buf_size)
 225 {
 226 #if 0
 227     if(pc->overread){
 228         printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
 229         printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
 230     }
 231 #endif
 232
 233     /* Copy overread bytes from last frame into buffer. */
 234     for(; pc->overread>0; pc->overread--){
 235         pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
 236     }
 237
 238     /* flush remaining if EOF */
 239     if(!*buf_size && next == END_NOT_FOUND){
 240         next= 0;
 241     }
 242
 243     pc->last_index= pc->index;
 244
 245     /* copy into buffer end return */
 246     if(next == END_NOT_FOUND){
 247         pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
 248
 249         memcpy(&pc->buffer[pc->index], *buf, *buf_size);
 250         pc->index += *buf_size;
 251         return -1;
 252     }
 253
 254     *buf_size=
 255     pc->overread_index= pc->index + next;
 256
 257     /* append to buffer */
 258     if(pc->index){
 259         pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
 260
 261         memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
 262         pc->index = 0;
 263         *buf= pc->buffer;
 264     }
 265
 266     /* store overread bytes */
 267     for(;next < 0; next++){
 268         pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
 269         pc->overread++;
 270     }
 271
 272 #if 0
 273     if(pc->overread){
 274         printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
 275         printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
 276     }
 277 #endif
 278
 279     return 0;
 280 }
 281
 282 void ff_parse_close(AVCodecParserContext *s)
 283 {
 284     ParseContext *pc = s->priv_data;
 285
 286     av_free(pc->buffer);
 287 }
 288
 289 void ff_parse1_close(AVCodecParserContext *s)
 290 {
 291     ParseContext1 *pc1 = s->priv_data;
 292
 293     av_free(pc1->pc.buffer);
 294     av_free(pc1->enc);
 295 }
 296
 297 /*************************/
 298
 299 int ff_mpeg4video_split(AVCodecContext *avctx,
 300                            const uint8_t *buf, int buf_size)
 301 {
 302     int i;
 303     uint32_t state= -1;
 304
 305     for(i=0; i<buf_size; i++){
 306         state= (state<<8) | buf[i];
 307         if(state == 0x1B3 || state == 0x1B6)
 308             return i-3;
 309     }
 310     return 0;
 311 }