undo changes in aac_ac3_parser

Originally committed as revision 12778 to svn://svn.ffmpeg.org/ffmpeg/trunk

libavcodec/aac_ac3_parser.c

@@ -29,38 +29,35 @@ int ff_aac_ac3_parse(AVCodecParserContext *s1,
                      const uint8_t *buf, int buf_size)
 {
     AACAC3ParseContext *s = s1->priv_data;
-    ParseContext *pc = &s->pc;
-    int len, i;
+    AACAC3FrameFlag frame_flag;
+    const uint8_t *buf_ptr;
+    int len;
 
-    while(s->remaining_size <= buf_size){
-        if(s->remaining_size && !s->need_next_header){
-            i= s->remaining_size;
-            s->remaining_size = 0;
-            goto output_frame;
-        }else{ //we need a header first
-            len=0;
-            for(i=s->remaining_size; i<buf_size; i++){
-                s->state = (s->state<<8) + buf[i];
-                if((len=s->sync(s->state, s, &s->need_next_header, &s->new_frame_start)))
-                    break;
-            }
-            i-= s->header_size -1;
-            if(len>0){
-                s->remaining_size = len + i;
+    *poutbuf = NULL;
+    *poutbuf_size = 0;
 
-                if(pc->index+i > 0 && s->new_frame_start){
-                    s->remaining_size -= i; // remaining_size=len
-output_frame:
-                    if(!s->frame_in_buffer){
-                        s->frame_in_buffer=1;
-                        buf+=i;
-                        buf_size-=i;
-                        continue;
-                    }
-                    ff_combine_frame(pc, i, &buf, &buf_size);
-                    *poutbuf = buf;
-                    *poutbuf_size = buf_size;
+    buf_ptr = buf;
+    while (buf_size > 0) {
+        int size_needed= s->frame_size ? s->frame_size : s->header_size;
+        len = s->inbuf_ptr - s->inbuf;
+
+        if(len<size_needed){
+            len = FFMIN(size_needed - len, buf_size);
+            memcpy(s->inbuf_ptr, buf_ptr, len);
+            buf_ptr      += len;
+            s->inbuf_ptr += len;
+            buf_size     -= len;
+        }
 
+        if (s->frame_size == 0) {
+            if ((s->inbuf_ptr - s->inbuf) == s->header_size) {
+                len = s->sync(s, &frame_flag);
+                if (len == 0) {
+                    /* no sync found : move by one byte (inefficient, but simple!) */
+                    memmove(s->inbuf, s->inbuf + 1, s->header_size - 1);
+                    s->inbuf_ptr--;
+                } else {
+                    s->frame_size = len;
                     /* update codec info */
                     avctx->sample_rate = s->sample_rate;
                     /* allow downmixing to stereo (or mono for AC3) */
@@ -75,19 +72,17 @@ output_frame:
                     }
                     avctx->bit_rate = s->bit_rate;
                     avctx->frame_size = s->samples;
-
-                    return i;
                 }
-                s->frame_in_buffer=1;
-            }else{
+            }
+        } else {
+            if(s->inbuf_ptr - s->inbuf == s->frame_size){
+                *poutbuf = s->inbuf;
+                *poutbuf_size = s->frame_size;
+                s->inbuf_ptr = s->inbuf;
+                s->frame_size = 0;
                 break;
             }
         }
     }
-
-    ff_combine_frame(pc, END_NOT_FOUND, &buf, &buf_size);
-    s->remaining_size -= FFMIN(s->remaining_size, buf_size);
-    *poutbuf = NULL;
-    *poutbuf_size = 0;
-    return buf_size;
+    return buf_ptr - buf;
 }

libavcodec/aac_ac3_parser.h

@@ -26,24 +26,23 @@
 #include <stdint.h>
 #include "avcodec.h"
 
+typedef enum{
+    FRAME_COMPLETE,    ///< Complete frame, ends previous frame
+    FRAME_START,       ///< Frame start, ends previous frame
+    FRAME_CONTINUATION ///< Part of the previous frame
+}AACAC3FrameFlag;
+
 typedef struct AACAC3ParseContext {
+    uint8_t *inbuf_ptr;
     int frame_size;
     int header_size;
-    int (*sync)(uint64_t state, struct AACAC3ParseContext *hdr_info,
-            int *need_next_header, int *new_frame_start);
+    int (*sync)(struct AACAC3ParseContext *hdr_info, AACAC3FrameFlag *flag);
+    uint8_t inbuf[8192]; /* input buffer */
 
     int channels;
     int sample_rate;
     int bit_rate;
     int samples;
-
-    ParseContext pc;
-    int remaining_size;
-    uint64_t state;
-
-    int need_next_header;
-    int new_frame_start;
-    int frame_in_buffer;
 } AACAC3ParseContext;
 
 int ff_aac_ac3_parse(AVCodecParserContext *s1,

libavcodec/aac_parser.c

@@ -27,14 +27,12 @@
 
 #define AAC_HEADER_SIZE 7
 
-static int aac_sync(uint64_t state, AACAC3ParseContext *hdr_info,
-        int *need_next_header, int *new_frame_start)
+static int aac_sync(AACAC3ParseContext *hdr_info, AACAC3FrameFlag *flag)
 {
     GetBitContext bits;
     int size, rdb, ch, sr;
-    uint64_t tmp = be2me_64(state);
 
-    init_get_bits(&bits, ((uint8_t *)&tmp)+8-AAC_HEADER_SIZE, AAC_HEADER_SIZE * 8);
+    init_get_bits(&bits, hdr_info->inbuf, AAC_HEADER_SIZE * 8);
 
     if(get_bits(&bits, 12) != 0xfff)
         return 0;
@@ -67,15 +65,15 @@ static int aac_sync(uint64_t state, AACAC3ParseContext *hdr_info,
     hdr_info->sample_rate = ff_mpeg4audio_sample_rates[sr];
     hdr_info->samples = (rdb + 1) * 1024;
     hdr_info->bit_rate = size * 8 * hdr_info->sample_rate / hdr_info->samples;
+    *flag = FRAME_COMPLETE;
 
-    *need_next_header=0;
-    *new_frame_start=1;
     return size;
 }
 
 static av_cold int aac_parse_init(AVCodecParserContext *s1)
 {
     AACAC3ParseContext *s = s1->priv_data;
+    s->inbuf_ptr = s->inbuf;
     s->header_size = AAC_HEADER_SIZE;
     s->sync = aac_sync;
     return 0;

libavcodec/ac3_parser.c

@@ -123,14 +123,12 @@ int ff_ac3_parse_header(const uint8_t buf[7], AC3HeaderInfo *hdr)
     return 0;
 }
 
-static int ac3_sync(uint64_t state, AACAC3ParseContext *hdr_info,
-        int *need_next_header, int *new_frame_start)
+static int ac3_sync(AACAC3ParseContext *hdr_info, AACAC3FrameFlag *flag)
 {
     int err;
-    uint64_t tmp = be2me_64(state);
     AC3HeaderInfo hdr;
 
-    err = ff_ac3_parse_header(((uint8_t *)&tmp)+8-AC3_HEADER_SIZE, &hdr);
+    err = ff_ac3_parse_header(hdr_info->inbuf, &hdr);
 
     if(err < 0)
         return 0;
@@ -140,14 +138,24 @@ static int ac3_sync(uint64_t state, AACAC3ParseContext *hdr_info,
     hdr_info->channels = hdr.channels;
     hdr_info->samples = AC3_FRAME_SIZE;
 
-    *need_next_header = (hdr.frame_type != EAC3_FRAME_TYPE_AC3_CONVERT);
-    *new_frame_start = (hdr.frame_type != EAC3_FRAME_TYPE_DEPENDENT);
+    switch(hdr.frame_type){
+        case EAC3_FRAME_TYPE_INDEPENDENT:
+            *flag = FRAME_START;
+            break;
+        case EAC3_FRAME_TYPE_DEPENDENT:
+            *flag = FRAME_CONTINUATION;
+            break;
+        case EAC3_FRAME_TYPE_AC3_CONVERT:
+            *flag = FRAME_COMPLETE;
+            break;
+    }
     return hdr.frame_size;
 }
 
 static av_cold int ac3_parse_init(AVCodecParserContext *s1)
 {
     AACAC3ParseContext *s = s1->priv_data;
+    s->inbuf_ptr = s->inbuf;
     s->header_size = AC3_HEADER_SIZE;
     s->sync = ac3_sync;
     return 0;