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