On piątek, 4 kwietnia 2008, Michael Niedermayer wrote:
> On Fri, Apr 04, 2008 at 07:44:46PM +0200, Bartlomiej Wolowiec wrote:
> > On piątek, 4 kwietnia 2008, Michael Niedermayer wrote:
> > > On Fri, Apr 04, 2008 at 01:45:44AM +0200, Michael Niedermayer wrote:
> > > > On Thu, Apr 03, 2008 at 11:53:22PM +0200, Bartlomiej Wolowiec wrote:
> > > > > On niedziela, 30 marca 2008, Michael Niedermayer wrote:
> > > > > > Note, to add the header into the buffer calling
> > > > > > ff_combine_frame() with END_NOT_FOUND and a smaller buffer size
> > > > > > should work.
> > > > > >
> > > > > > After its in the buffer you just run the header decoder thing
> > > > > > over the header and when you know the final frame size you call
> > > > > > ff_combine_frame with appropriate next value.
> > > > > >
> > > > > > Anyway iam not insisting on you changing the current aac/ac3
> > > > > > parser to use ff_combine_frame()
> > > > > > But what you will end up implementing will be quite similar in
> > > > > > functionality to ff_combine_frame()
> > > > > >
> > > > > > [...]
> > > > >
> > > > > Hmm...
> > > > > I tried to implement it using ff_combine_frame, but the code which
> > > > > I got is in my opinion significantly worse. Main problems which I
> > > > > had: -ff_combine_frame is rather adapted to using on one frame,
> > > > > when in buffer is one frame and it currently reads the next one it
> > > > > isn't convenient (the whole buffer size is not just a new frame's
> > > > > size, so that we should remember size of earlier frames).
> > > > > -in the genuine code there is
> > > > > memmove(s->frame_start, s->frame_start + 1, s->header_size - 1);
> > > > > s->frame_ptr--;
> > > > > here we can operate on pc->buffer and pc->index (remembering also
> > > > > where the new frame begins). However, surely it isn't the simpliest
> > > > > solution...
> > > >
> > > > What i had in mind is below, this is blindly written and likely
> > > > contains bugs. I did spot one each time i looked at it :)
> > > > But it does not look fundamentally worse to me, it also has the
> > > > advantage that its not full of unneeded memcpys and memmoves.
> > > >
> > > > 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
> > > > for(i=s->remaining_size; i<buf_size; i++){
> > > > ctx->state= (ctx->state<<8) + buf[i];
> > > > if((len=parse_header(ctx->state, &s->need_next_header,
> > > > &s->new_frame_start)))
> > >
> > > just to clarify before you ask ...
> > > state is a 64bit variable in your context unrelated to the 32bit state
> > > ff_combine_frame() plays with.
> > >
> > > [...]
> >
> > The code works almost perfectly, but I have two questions:
> > -is there any effective method of getting bitstream from uint64_t (or it
> > should be "unpacked" to 8-byte array)?
>
> uint64_t tmp= be2me_64(state);
> init_get_bits(&tmp);
>
> > -why the number of channels is set in parser?
>
> streamcopy mpeg-ps -> anything
> first doesnt have a header with a channel number second does.
>
> > I have this question because the
> > number of channels in eac3 depends on chanmap, to read which there it
> > needs 92 bits of header. (or I should put there something like x = (x<<8)
> > + (y>>56); y = (y<<8) + buf[i]; and keep 128 last bits?)
>
> well, thats a possibility.
> a
> buf[16];
> memmove(buf)
> buf[15]= *b++;
> would be a possibility as well
>
> a third one (and i think its the best one) is
> just to read the header with the channel num before the returning it after
> ff_combine_frame(). It has to be a complete frame at that point, also
> please reuse the code from the decoder for this if possible!
>
> [...]
ok, I enclose patch based on your code.
--
Bartlomiej Wolowiec
Index: libavcodec/aac_ac3_parser.c
===================================================================
--- libavcodec/aac_ac3_parser.c (wersja 12668)
+++ libavcodec/aac_ac3_parser.c (kopia robocza)
@@ -29,35 +29,32 @@
const uint8_t *buf, int buf_size)
{
AACAC3ParseContext *s = s1->priv_data;
- AACAC3FrameFlag frame_flag;
const uint8_t *buf_ptr;
- int len;
+ ParseContext *pc = &s->pc;
+ int len, i;
- *poutbuf = NULL;
- *poutbuf_size = 0;
+ 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
+ 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;
+ if(len>0){
+ s->remaining_size = len + i;
- 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(pc->index+i > 0 && s->new_frame_start){
+ s->remaining_size -= i; // remaining_size=len
+output_frame:
+ ff_combine_frame(pc, i, &buf, &buf_size);
+ *poutbuf = buf;
+ *poutbuf_size = buf_size;
- 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) */
@@ -72,17 +69,18 @@
}
avctx->bit_rate = s->bit_rate;
avctx->frame_size = s->samples;
+
+ return i;
}
- }
- } 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;
+ }else{
break;
}
}
}
- return buf_ptr - buf;
+
+ 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;
}
Index: libavcodec/aac_ac3_parser.h
===================================================================
--- libavcodec/aac_ac3_parser.h (wersja 12668)
+++ libavcodec/aac_ac3_parser.h (kopia robocza)
@@ -26,23 +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)(struct AACAC3ParseContext *hdr_info, AACAC3FrameFlag *flag);
- uint8_t inbuf[8192]; /* input buffer */
+ int (*sync)(uint64_t state, struct AACAC3ParseContext *hdr_info,
+ int *need_next_header, int *new_frame_start);
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;
} AACAC3ParseContext;
int ff_aac_ac3_parse(AVCodecParserContext *s1,
Index: libavcodec/aac_parser.c
===================================================================
--- libavcodec/aac_parser.c (wersja 12668)
+++ libavcodec/aac_parser.c (kopia robocza)
@@ -27,12 +27,14 @@
#define AAC_HEADER_SIZE 7
-static int aac_sync(AACAC3ParseContext *hdr_info, AACAC3FrameFlag *flag)
+static int aac_sync(uint64_t state, AACAC3ParseContext *hdr_info,
+ int *need_next_header, int *new_frame_start)
{
GetBitContext bits;
int size, rdb, ch, sr;
+ uint64_t tmp = be2me_64(state);
- init_get_bits(&bits, hdr_info->inbuf, AAC_HEADER_SIZE * 8);
+ init_get_bits(&bits, (uint8_t *)&tmp, AAC_HEADER_SIZE * 8);
if(get_bits(&bits, 12) != 0xfff)
return 0;
@@ -65,15 +67,15 @@
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;
Index: libavcodec/ac3_parser.c
===================================================================
--- libavcodec/ac3_parser.c (wersja 12668)
+++ libavcodec/ac3_parser.c (kopia robocza)
@@ -123,12 +123,14 @@
return 0;
}
-static int ac3_sync(AACAC3ParseContext *hdr_info, AACAC3FrameFlag *flag)
+static int ac3_sync(uint64_t state, AACAC3ParseContext *hdr_info,
+ int *need_next_header, int *new_frame_start)
{
int err;
+ uint64_t tmp = be2me_64(state);
AC3HeaderInfo hdr;
- err = ff_ac3_parse_header(hdr_info->inbuf, &hdr);
+ err = ff_ac3_parse_header(&tmp, &hdr);
if(err < 0)
return 0;
@@ -138,24 +140,14 @@
hdr_info->channels = hdr.channels;
hdr_info->samples = AC3_FRAME_SIZE;
- 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;
- }
+ *need_next_header = (hdr.frame_type != EAC3_FRAME_TYPE_AC3_CONVERT);
+ *new_frame_start = (hdr.frame_type != EAC3_FRAME_TYPE_DEPENDENT);
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;
_______________________________________________
FFmpeg-soc mailing list
[email protected]
https://lists.mplayerhq.hu/mailman/listinfo/ffmpeg-soc
