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 library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20 #include "avcodec.h"
  21 #include "mpegvideo.h"
  22 #include "mpegaudio.h"
  23
  24 AVCodecParser *av_first_parser = NULL;
  25
  26 void av_register_codec_parser(AVCodecParser *parser)
  27 {
  28     parser->next = av_first_parser;
  29     av_first_parser = parser;
  30 }
  31
  32 AVCodecParserContext *av_parser_init(int codec_id)
  33 {
  34     AVCodecParserContext *s;
  35     AVCodecParser *parser;
  36     int ret;
  37
  38     for(parser = av_first_parser; parser != NULL; parser = parser->next) {
  39         if (parser->codec_ids[0] == codec_id ||
  40             parser->codec_ids[1] == codec_id ||
  41             parser->codec_ids[2] == codec_id ||
  42             parser->codec_ids[3] == codec_id ||
  43             parser->codec_ids[4] == codec_id)
  44             goto found;
  45     }
  46     return NULL;
  47  found:
  48     s = av_mallocz(sizeof(AVCodecParserContext));
  49     if (!s)
  50         return NULL;
  51     s->parser = parser;
  52     s->priv_data = av_mallocz(parser->priv_data_size);
  53     if (!s->priv_data) {
  54         av_free(s);
  55         return NULL;
  56     }
  57     if (parser->parser_init) {
  58         ret = parser->parser_init(s);
  59         if (ret != 0) {
  60             av_free(s->priv_data);
  61             av_free(s);
  62             return NULL;
  63         }
  64     }
  65     s->fetch_timestamp=1;
  66     return s;
  67 }
  68
  69 /* NOTE: buf_size == 0 is used to signal EOF so that the last frame
  70    can be returned if necessary */
  71 int av_parser_parse(AVCodecParserContext *s,
  72                     AVCodecContext *avctx,
  73                     uint8_t **poutbuf, int *poutbuf_size,
  74                     const uint8_t *buf, int buf_size,
  75                     int64_t pts, int64_t dts)
  76 {
  77     int index, i, k;
  78     uint8_t dummy_buf[FF_INPUT_BUFFER_PADDING_SIZE];
  79
  80     if (buf_size == 0) {
  81         /* padding is always necessary even if EOF, so we add it here */
  82         memset(dummy_buf, 0, sizeof(dummy_buf));
  83         buf = dummy_buf;
  84     } else {
  85         /* add a new packet descriptor */
  86         k = (s->cur_frame_start_index + 1) & (AV_PARSER_PTS_NB - 1);
  87         s->cur_frame_start_index = k;
  88         s->cur_frame_offset[k] = s->cur_offset;
  89         s->cur_frame_pts[k] = pts;
  90         s->cur_frame_dts[k] = dts;
  91
  92         /* fill first PTS/DTS */
  93         if (s->fetch_timestamp){
  94             s->fetch_timestamp=0;
  95             s->last_pts = pts;
  96             s->last_dts = dts;
  97             s->cur_frame_pts[k] =
  98             s->cur_frame_dts[k] = AV_NOPTS_VALUE;
  99         }
 100     }
 101
 102     /* WARNING: the returned index can be negative */
 103     index = s->parser->parser_parse(s, avctx, poutbuf, poutbuf_size, buf, buf_size);
 104 //av_log(NULL, AV_LOG_DEBUG, "parser: in:%lld, %lld, out:%lld, %lld, in:%d out:%d id:%d\n", pts, dts, s->last_pts, s->last_dts, buf_size, *poutbuf_size, avctx->codec_id);
 105     /* update the file pointer */
 106     if (*poutbuf_size) {
 107         /* fill the data for the current frame */
 108         s->frame_offset = s->last_frame_offset;
 109         s->pts = s->last_pts;
 110         s->dts = s->last_dts;
 111
 112         /* offset of the next frame */
 113         s->last_frame_offset = s->cur_offset + index;
 114         /* find the packet in which the new frame starts. It
 115            is tricky because of MPEG video start codes
 116            which can begin in one packet and finish in
 117            another packet. In the worst case, an MPEG
 118            video start code could be in 4 different
 119            packets. */
 120         k = s->cur_frame_start_index;
 121         for(i = 0; i < AV_PARSER_PTS_NB; i++) {
 122             if (s->last_frame_offset >= s->cur_frame_offset[k])
 123                 break;
 124             k = (k - 1) & (AV_PARSER_PTS_NB - 1);
 125         }
 126
 127         s->last_pts = s->cur_frame_pts[k];
 128         s->last_dts = s->cur_frame_dts[k];
 129
 130         /* some parsers tell us the packet size even before seeing the first byte of the next packet,
 131            so the next pts/dts is in the next chunk */
 132         if(index == buf_size){
 133             s->fetch_timestamp=1;
 134         }
 135     }
 136     if (index < 0)
 137         index = 0;
 138     s->cur_offset += index;
 139     return index;
 140 }
 141
 142 void av_parser_close(AVCodecParserContext *s)
 143 {
 144     if (s->parser->parser_close)
 145         s->parser->parser_close(s);
 146     av_free(s->priv_data);
 147     av_free(s);
 148 }
 149
 150 /*****************************************************/
 151
 152 //#define END_NOT_FOUND (-100)
 153
 154 #define PICTURE_START_CODE      0x00000100
 155 #define SEQ_START_CODE          0x000001b3
 156 #define EXT_START_CODE          0x000001b5
 157 #define SLICE_MIN_START_CODE    0x00000101
 158 #define SLICE_MAX_START_CODE    0x000001af
 159
 160 typedef struct ParseContext1{
 161     ParseContext pc;
 162 /* XXX/FIXME PC1 vs. PC */
 163     /* MPEG2 specific */
 164     int frame_rate;
 165     int progressive_sequence;
 166     int width, height;
 167
 168     /* XXX: suppress that, needed by MPEG4 */
 169     MpegEncContext *enc;
 170     int first_picture;
 171 } ParseContext1;
 172
 173 /**
 174  * combines the (truncated) bitstream to a complete frame
 175  * @returns -1 if no complete frame could be created
 176  */
 177 int ff_combine_frame(ParseContext *pc, int next, uint8_t **buf, int *buf_size)
 178 {
 179 #if 0
 180     if(pc->overread){
 181         printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
 182         printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
 183     }
 184 #endif
 185
 186     /* copy overreaded bytes from last frame into buffer */
 187     for(; pc->overread>0; pc->overread--){
 188         pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
 189     }
 190
 191     /* flush remaining if EOF */
 192     if(!*buf_size && next == END_NOT_FOUND){
 193         next= 0;
 194     }
 195
 196     pc->last_index= pc->index;
 197
 198     /* copy into buffer end return */
 199     if(next == END_NOT_FOUND){
 200         pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, (*buf_size) + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
 201
 202         memcpy(&pc->buffer[pc->index], *buf, *buf_size);
 203         pc->index += *buf_size;
 204         return -1;
 205     }
 206
 207     *buf_size=
 208     pc->overread_index= pc->index + next;
 209
 210     /* append to buffer */
 211     if(pc->index){
 212         pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
 213
 214         memcpy(&pc->buffer[pc->index], *buf, next + FF_INPUT_BUFFER_PADDING_SIZE );
 215         pc->index = 0;
 216         *buf= pc->buffer;
 217     }
 218
 219     /* store overread bytes */
 220     for(;next < 0; next++){
 221         pc->state = (pc->state<<8) | pc->buffer[pc->last_index + next];
 222         pc->overread++;
 223     }
 224
 225 #if 0
 226     if(pc->overread){
 227         printf("overread %d, state:%X next:%d index:%d o_index:%d\n", pc->overread, pc->state, next, pc->index, pc->overread_index);
 228         printf("%X %X %X %X\n", (*buf)[0], (*buf)[1],(*buf)[2],(*buf)[3]);
 229     }
 230 #endif
 231
 232     return 0;
 233 }
 234
 235 static int find_start_code(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
 236 {
 237     const uint8_t *buf_ptr;
 238     unsigned int state=0xFFFFFFFF, v;
 239     int val;
 240
 241     buf_ptr = *pbuf_ptr;
 242     while (buf_ptr < buf_end) {
 243         v = *buf_ptr++;
 244         if (state == 0x000001) {
 245             state = ((state << 8) | v) & 0xffffff;
 246             val = state;
 247             goto found;
 248         }
 249         state = ((state << 8) | v) & 0xffffff;
 250     }
 251     val = -1;
 252  found:
 253     *pbuf_ptr = buf_ptr;
 254     return val;
 255 }
 256
 257 /* XXX: merge with libavcodec ? */
 258 #define MPEG1_FRAME_RATE_BASE 1001
 259
 260 static const int frame_rate_tab[16] = {
 261         0,
 262     24000,
 263     24024,
 264     25025,
 265     30000,
 266     30030,
 267     50050,
 268     60000,
 269     60060,
 270   // Xing's 15fps: (9)
 271     15015,
 272   // libmpeg3's "Unofficial economy rates": (10-13)
 273      5005,
 274     10010,
 275     12012,
 276     15015,
 277   // random, just to avoid segfault !never encode these
 278     25025,
 279     25025,
 280 };
 281
 282 static void mpegvideo_extract_headers(AVCodecParserContext *s,
 283                                       AVCodecContext *avctx,
 284                                       const uint8_t *buf, int buf_size)
 285 {
 286     ParseContext1 *pc = s->priv_data;
 287     const uint8_t *buf_end;
 288     int32_t start_code;
 289     int frame_rate_index, ext_type, bytes_left;
 290     int frame_rate_ext_n, frame_rate_ext_d;
 291     int picture_structure, top_field_first, repeat_first_field, progressive_frame;
 292     int horiz_size_ext, vert_size_ext;
 293
 294     s->repeat_pict = 0;
 295     buf_end = buf + buf_size;
 296     while (buf < buf_end) {
 297         start_code = find_start_code(&buf, buf_end);
 298         bytes_left = buf_end - buf;
 299         switch(start_code) {
 300         case PICTURE_START_CODE:
 301             if (bytes_left >= 2) {
 302                 s->pict_type = (buf[1] >> 3) & 7;
 303             }
 304             break;
 305         case SEQ_START_CODE:
 306             if (bytes_left >= 4) {
 307                 pc->width  = (buf[0] << 4) | (buf[1] >> 4);
 308                 pc->height = ((buf[1] & 0x0f) << 8) | buf[2];
 309                 avcodec_set_dimensions(avctx, pc->width, pc->height);
 310                 frame_rate_index = buf[3] & 0xf;
 311                 pc->frame_rate = avctx->frame_rate = frame_rate_tab[frame_rate_index];
 312                 avctx->frame_rate_base = MPEG1_FRAME_RATE_BASE;
 313                 avctx->codec_id = CODEC_ID_MPEG1VIDEO;
 314                 avctx->sub_id = 1;
 315             }
 316             break;
 317         case EXT_START_CODE:
 318             if (bytes_left >= 1) {
 319                 ext_type = (buf[0] >> 4);
 320                 switch(ext_type) {
 321                 case 0x1: /* sequence extension */
 322                     if (bytes_left >= 6) {
 323                         horiz_size_ext = ((buf[1] & 1) << 1) | (buf[2] >> 7);
 324                         vert_size_ext = (buf[2] >> 5) & 3;
 325                         frame_rate_ext_n = (buf[5] >> 5) & 3;
 326                         frame_rate_ext_d = (buf[5] & 0x1f);
 327                         pc->progressive_sequence = buf[1] & (1 << 3);
 328                         avctx->has_b_frames= buf[5] >> 7;
 329
 330                         pc->width  |=(horiz_size_ext << 12);
 331                         pc->height |=( vert_size_ext << 12);
 332                         avcodec_set_dimensions(avctx, pc->width, pc->height);
 333                         avctx->frame_rate = pc->frame_rate * (frame_rate_ext_n + 1);
 334                         avctx->frame_rate_base = MPEG1_FRAME_RATE_BASE * (frame_rate_ext_d + 1);
 335                         avctx->codec_id = CODEC_ID_MPEG2VIDEO;
 336                         avctx->sub_id = 2; /* forces MPEG2 */
 337                     }
 338                     break;
 339                 case 0x8: /* picture coding extension */
 340                     if (bytes_left >= 5) {
 341                         picture_structure = buf[2]&3;
 342                         top_field_first = buf[3] & (1 << 7);
 343                         repeat_first_field = buf[3] & (1 << 1);
 344                         progressive_frame = buf[4] & (1 << 7);
 345
 346                         /* check if we must repeat the frame */
 347                         if (repeat_first_field) {
 348                             if (pc->progressive_sequence) {
 349                                 if (top_field_first)
 350                                     s->repeat_pict = 4;
 351                                 else
 352                                     s->repeat_pict = 2;
 353                             } else if (progressive_frame) {
 354                                 s->repeat_pict = 1;
 355                             }
 356                         }
 357
 358                         /* the packet only represents half a frame
 359                            XXX,FIXME maybe find a different solution */
 360                         if(picture_structure != 3)
 361                             s->repeat_pict = -1;
 362                     }
 363                     break;
 364                 }
 365             }
 366             break;
 367         case -1:
 368             goto the_end;
 369         default:
 370             /* we stop parsing when we encounter a slice. It ensures
 371                that this function takes a negligible amount of time */
 372             if (start_code >= SLICE_MIN_START_CODE &&
 373                 start_code <= SLICE_MAX_START_CODE)
 374                 goto the_end;
 375             break;
 376         }
 377     }
 378  the_end: ;
 379 }
 380
 381 static int mpegvideo_parse(AVCodecParserContext *s,
 382                            AVCodecContext *avctx,
 383                            uint8_t **poutbuf, int *poutbuf_size,
 384                            const uint8_t *buf, int buf_size)
 385 {
 386     ParseContext1 *pc1 = s->priv_data;
 387     ParseContext *pc= &pc1->pc;
 388     int next;
 389
 390     next= ff_mpeg1_find_frame_end(pc, buf, buf_size);
 391
 392     if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
 393         *poutbuf = NULL;
 394         *poutbuf_size = 0;
 395         return buf_size;
 396     }
 397     /* we have a full frame : we just parse the first few MPEG headers
 398        to have the full timing information. The time take by this
 399        function should be negligible for uncorrupted streams */
 400     mpegvideo_extract_headers(s, avctx, buf, buf_size);
 401 #if 0
 402     printf("pict_type=%d frame_rate=%0.3f repeat_pict=%d\n",
 403            s->pict_type, (double)avctx->frame_rate / avctx->frame_rate_base, s->repeat_pict);
 404 #endif
 405
 406     *poutbuf = (uint8_t *)buf;
 407     *poutbuf_size = buf_size;
 408     return next;
 409 }
 410
 411 void ff_parse_close(AVCodecParserContext *s)
 412 {
 413     ParseContext *pc = s->priv_data;
 414
 415     av_free(pc->buffer);
 416 }
 417
 418 static void parse1_close(AVCodecParserContext *s)
 419 {
 420     ParseContext1 *pc1 = s->priv_data;
 421
 422     av_free(pc1->pc.buffer);
 423     av_free(pc1->enc);
 424 }
 425
 426 /*************************/
 427
 428 /* used by parser */
 429 /* XXX: make it use less memory */
 430 static int av_mpeg4_decode_header(AVCodecParserContext *s1,
 431                                   AVCodecContext *avctx,
 432                                   const uint8_t *buf, int buf_size)
 433 {
 434     ParseContext1 *pc = s1->priv_data;
 435     MpegEncContext *s = pc->enc;
 436     GetBitContext gb1, *gb = &gb1;
 437     int ret;
 438
 439     s->avctx = avctx;
 440     s->current_picture_ptr = &s->current_picture;
 441
 442     if (avctx->extradata_size && pc->first_picture){
 443         init_get_bits(gb, avctx->extradata, avctx->extradata_size*8);
 444         ret = ff_mpeg4_decode_picture_header(s, gb);
 445     }
 446
 447     init_get_bits(gb, buf, 8 * buf_size);
 448     ret = ff_mpeg4_decode_picture_header(s, gb);
 449     if (s->width) {
 450         avcodec_set_dimensions(avctx, s->width, s->height);
 451     }
 452     pc->first_picture = 0;
 453     return ret;
 454 }
 455
 456 static int mpeg4video_parse_init(AVCodecParserContext *s)
 457 {
 458     ParseContext1 *pc = s->priv_data;
 459
 460     pc->enc = av_mallocz(sizeof(MpegEncContext));
 461     if (!pc->enc)
 462         return -1;
 463     pc->first_picture = 1;
 464     return 0;
 465 }
 466
 467 static int mpeg4video_parse(AVCodecParserContext *s,
 468                            AVCodecContext *avctx,
 469                            uint8_t **poutbuf, int *poutbuf_size,
 470                            const uint8_t *buf, int buf_size)
 471 {
 472     ParseContext *pc = s->priv_data;
 473     int next;
 474
 475     next= ff_mpeg4_find_frame_end(pc, buf, buf_size);
 476
 477     if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
 478         *poutbuf = NULL;
 479         *poutbuf_size = 0;
 480         return buf_size;
 481     }
 482     av_mpeg4_decode_header(s, avctx, buf, buf_size);
 483
 484     *poutbuf = (uint8_t *)buf;
 485     *poutbuf_size = buf_size;
 486     return next;
 487 }
 488
 489 /*************************/
 490
 491 typedef struct MpegAudioParseContext {
 492     uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE];    /* input buffer */
 493     uint8_t *inbuf_ptr;
 494     int frame_size;
 495     int free_format_frame_size;
 496     int free_format_next_header;
 497 } MpegAudioParseContext;
 498
 499 #define MPA_HEADER_SIZE 4
 500
 501 /* header + layer + bitrate + freq + lsf/mpeg25 */
 502 #define SAME_HEADER_MASK \
 503    (0xffe00000 | (3 << 17) | (0xf << 12) | (3 << 10) | (3 << 19))
 504
 505 static int mpegaudio_parse_init(AVCodecParserContext *s1)
 506 {
 507     MpegAudioParseContext *s = s1->priv_data;
 508     s->inbuf_ptr = s->inbuf;
 509     return 0;
 510 }
 511
 512 static int mpegaudio_parse(AVCodecParserContext *s1,
 513                            AVCodecContext *avctx,
 514                            uint8_t **poutbuf, int *poutbuf_size,
 515                            const uint8_t *buf, int buf_size)
 516 {
 517     MpegAudioParseContext *s = s1->priv_data;
 518     int len, ret;
 519     uint32_t header;
 520     const uint8_t *buf_ptr;
 521
 522     *poutbuf = NULL;
 523     *poutbuf_size = 0;
 524     buf_ptr = buf;
 525     while (buf_size > 0) {
 526         len = s->inbuf_ptr - s->inbuf;
 527         if (s->frame_size == 0) {
 528             /* special case for next header for first frame in free
 529                format case (XXX: find a simpler method) */
 530             if (s->free_format_next_header != 0) {
 531                 s->inbuf[0] = s->free_format_next_header >> 24;
 532                 s->inbuf[1] = s->free_format_next_header >> 16;
 533                 s->inbuf[2] = s->free_format_next_header >> 8;
 534                 s->inbuf[3] = s->free_format_next_header;
 535                 s->inbuf_ptr = s->inbuf + 4;
 536                 s->free_format_next_header = 0;
 537                 goto got_header;
 538             }
 539             /* no header seen : find one. We need at least MPA_HEADER_SIZE
 540                bytes to parse it */
 541             len = MPA_HEADER_SIZE - len;
 542             if (len > buf_size)
 543                 len = buf_size;
 544             if (len > 0) {
 545                 memcpy(s->inbuf_ptr, buf_ptr, len);
 546                 buf_ptr += len;
 547                 buf_size -= len;
 548                 s->inbuf_ptr += len;
 549             }
 550             if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
 551             got_header:
 552                 header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
 553                     (s->inbuf[2] << 8) | s->inbuf[3];
 554
 555                 ret = mpa_decode_header(avctx, header);
 556                 if (ret < 0) {
 557                     /* no sync found : move by one byte (inefficient, but simple!) */
 558                     memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
 559                     s->inbuf_ptr--;
 560                     dprintf("skip %x\n", header);
 561                     /* reset free format frame size to give a chance
 562                        to get a new bitrate */
 563                     s->free_format_frame_size = 0;
 564                 } else {
 565                     s->frame_size = ret;
 566 #if 0
 567                     /* free format: prepare to compute frame size */
 568                     if (decode_header(s, header) == 1) {
 569                         s->frame_size = -1;
 570                     }
 571 #endif
 572                 }
 573             }
 574         } else
 575 #if 0
 576         if (s->frame_size == -1) {
 577             /* free format : find next sync to compute frame size */
 578             len = MPA_MAX_CODED_FRAME_SIZE - len;
 579             if (len > buf_size)
 580                 len = buf_size;
 581             if (len == 0) {
 582                 /* frame too long: resync */
 583                 s->frame_size = 0;
 584                 memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
 585                 s->inbuf_ptr--;
 586             } else {
 587                 uint8_t *p, *pend;
 588                 uint32_t header1;
 589                 int padding;
 590
 591                 memcpy(s->inbuf_ptr, buf_ptr, len);
 592                 /* check for header */
 593                 p = s->inbuf_ptr - 3;
 594                 pend = s->inbuf_ptr + len - 4;
 595                 while (p <= pend) {
 596                     header = (p[0] << 24) | (p[1] << 16) |
 597                         (p[2] << 8) | p[3];
 598                     header1 = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
 599                         (s->inbuf[2] << 8) | s->inbuf[3];
 600                     /* check with high probability that we have a
 601                        valid header */
 602                     if ((header & SAME_HEADER_MASK) ==
 603                         (header1 & SAME_HEADER_MASK)) {
 604                         /* header found: update pointers */
 605                         len = (p + 4) - s->inbuf_ptr;
 606                         buf_ptr += len;
 607                         buf_size -= len;
 608                         s->inbuf_ptr = p;
 609                         /* compute frame size */
 610                         s->free_format_next_header = header;
 611                         s->free_format_frame_size = s->inbuf_ptr - s->inbuf;
 612                         padding = (header1 >> 9) & 1;
 613                         if (s->layer == 1)
 614                             s->free_format_frame_size -= padding * 4;
 615                         else
 616                             s->free_format_frame_size -= padding;
 617                         dprintf("free frame size=%d padding=%d\n",
 618                                 s->free_format_frame_size, padding);
 619                         decode_header(s, header1);
 620                         goto next_data;
 621                     }
 622                     p++;
 623                 }
 624                 /* not found: simply increase pointers */
 625                 buf_ptr += len;
 626                 s->inbuf_ptr += len;
 627                 buf_size -= len;
 628             }
 629         } else
 630 #endif
 631         if (len < s->frame_size) {
 632             if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)
 633                 s->frame_size = MPA_MAX_CODED_FRAME_SIZE;
 634             len = s->frame_size - len;
 635             if (len > buf_size)
 636                 len = buf_size;
 637             memcpy(s->inbuf_ptr, buf_ptr, len);
 638             buf_ptr += len;
 639             s->inbuf_ptr += len;
 640             buf_size -= len;
 641         }
 642         //    next_data:
 643         if (s->frame_size > 0 &&
 644             (s->inbuf_ptr - s->inbuf) >= s->frame_size) {
 645             *poutbuf = s->inbuf;
 646             *poutbuf_size = s->inbuf_ptr - s->inbuf;
 647             s->inbuf_ptr = s->inbuf;
 648             s->frame_size = 0;
 649             break;
 650         }
 651     }
 652     return buf_ptr - buf;
 653 }
 654
 655 #ifdef CONFIG_AC3
 656 extern int a52_syncinfo (const uint8_t * buf, int * flags,
 657                          int * sample_rate, int * bit_rate);
 658
 659 typedef struct AC3ParseContext {
 660     uint8_t inbuf[4096]; /* input buffer */
 661     uint8_t *inbuf_ptr;
 662     int frame_size;
 663     int flags;
 664 } AC3ParseContext;
 665
 666 #define AC3_HEADER_SIZE 7
 667 #define A52_LFE 16
 668
 669 static int ac3_parse_init(AVCodecParserContext *s1)
 670 {
 671     AC3ParseContext *s = s1->priv_data;
 672     s->inbuf_ptr = s->inbuf;
 673     return 0;
 674 }
 675
 676 static int ac3_parse(AVCodecParserContext *s1,
 677                      AVCodecContext *avctx,
 678                      uint8_t **poutbuf, int *poutbuf_size,
 679                      const uint8_t *buf, int buf_size)
 680 {
 681     AC3ParseContext *s = s1->priv_data;
 682     const uint8_t *buf_ptr;
 683     int len, sample_rate, bit_rate;
 684     static const int ac3_channels[8] = {
 685         2, 1, 2, 3, 3, 4, 4, 5
 686     };
 687
 688     *poutbuf = NULL;
 689     *poutbuf_size = 0;
 690
 691     buf_ptr = buf;
 692     while (buf_size > 0) {
 693         len = s->inbuf_ptr - s->inbuf;
 694         if (s->frame_size == 0) {
 695             /* no header seen : find one. We need at least 7 bytes to parse it */
 696             len = AC3_HEADER_SIZE - len;
 697             if (len > buf_size)
 698                 len = buf_size;
 699             memcpy(s->inbuf_ptr, buf_ptr, len);
 700             buf_ptr += len;
 701             s->inbuf_ptr += len;
 702             buf_size -= len;
 703             if ((s->inbuf_ptr - s->inbuf) == AC3_HEADER_SIZE) {
 704                 len = a52_syncinfo(s->inbuf, &s->flags, &sample_rate, &bit_rate);
 705                 if (len == 0) {
 706                     /* no sync found : move by one byte (inefficient, but simple!) */
 707                     memmove(s->inbuf, s->inbuf + 1, AC3_HEADER_SIZE - 1);
 708                     s->inbuf_ptr--;
 709                 } else {
 710                     s->frame_size = len;
 711                     /* update codec info */
 712                     avctx->sample_rate = sample_rate;
 713                     /* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
 714                     if(avctx->channels!=1 && avctx->channels!=2){
 715                         avctx->channels = ac3_channels[s->flags & 7];
 716                         if (s->flags & A52_LFE)
 717                             avctx->channels++;
 718                     }
 719                     avctx->bit_rate = bit_rate;
 720                     avctx->frame_size = 6 * 256;
 721                 }
 722             }
 723         } else if (len < s->frame_size) {
 724             len = s->frame_size - len;
 725             if (len > buf_size)
 726                 len = buf_size;
 727
 728             memcpy(s->inbuf_ptr, buf_ptr, len);
 729             buf_ptr += len;
 730             s->inbuf_ptr += len;
 731             buf_size -= len;
 732         } else {
 733             *poutbuf = s->inbuf;
 734             *poutbuf_size = s->frame_size;
 735             s->inbuf_ptr = s->inbuf;
 736             s->frame_size = 0;
 737             break;
 738         }
 739     }
 740     return buf_ptr - buf;
 741 }
 742 #endif
 743
 744 AVCodecParser mpegvideo_parser = {
 745     { CODEC_ID_MPEG1VIDEO, CODEC_ID_MPEG2VIDEO },
 746     sizeof(ParseContext1),
 747     NULL,
 748     mpegvideo_parse,
 749     parse1_close,
 750 };
 751
 752 AVCodecParser mpeg4video_parser = {
 753     { CODEC_ID_MPEG4 },
 754     sizeof(ParseContext1),
 755     mpeg4video_parse_init,
 756     mpeg4video_parse,
 757     parse1_close,
 758 };
 759
 760 AVCodecParser mpegaudio_parser = {
 761     { CODEC_ID_MP2, CODEC_ID_MP3 },
 762     sizeof(MpegAudioParseContext),
 763     mpegaudio_parse_init,
 764     mpegaudio_parse,
 765     NULL,
 766 };
 767
 768 #ifdef CONFIG_AC3
 769 AVCodecParser ac3_parser = {
 770     { CODEC_ID_AC3 },
 771     sizeof(AC3ParseContext),
 772     ac3_parse_init,
 773     ac3_parse,
 774     NULL,
 775 };
 776 #endif