*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "avcodec.h"
#include "mpegvideo.h"
AVCodecParser *parser;
int ret;
+ if(codec_id == CODEC_ID_NONE)
+ return NULL;
+
for(parser = av_first_parser; parser != NULL; parser = parser->next) {
if (parser->codec_ids[0] == codec_id ||
parser->codec_ids[1] == codec_id ||
- parser->codec_ids[2] == codec_id)
+ parser->codec_ids[2] == codec_id ||
+ parser->codec_ids[3] == codec_id ||
+ parser->codec_ids[4] == codec_id)
goto found;
}
return NULL;
/* NOTE: buf_size == 0 is used to signal EOF so that the last frame
can be returned if necessary */
-int av_parser_parse(AVCodecParserContext *s,
+int av_parser_parse(AVCodecParserContext *s,
AVCodecContext *avctx,
- uint8_t **poutbuf, int *poutbuf_size,
+ uint8_t **poutbuf, int *poutbuf_size,
const uint8_t *buf, int buf_size,
int64_t pts, int64_t dts)
{
int index, i, k;
uint8_t dummy_buf[FF_INPUT_BUFFER_PADDING_SIZE];
-
+
if (buf_size == 0) {
/* padding is always necessary even if EOF, so we add it here */
memset(dummy_buf, 0, sizeof(dummy_buf));
s->frame_offset = s->last_frame_offset;
s->pts = s->last_pts;
s->dts = s->last_dts;
-
+
/* offset of the next frame */
s->last_frame_offset = s->cur_offset + index;
/* find the packet in which the new frame starts. It
s->last_pts = s->cur_frame_pts[k];
s->last_dts = s->cur_frame_dts[k];
-
+
/* some parsers tell us the packet size even before seeing the first byte of the next packet,
so the next pts/dts is in the next chunk */
if(index == buf_size){
return index;
}
+/**
+ *
+ * @return 0 if the output buffer is a subset of the input, 1 if it is allocated and must be freed
+ */
+int av_parser_change(AVCodecParserContext *s,
+ AVCodecContext *avctx,
+ uint8_t **poutbuf, int *poutbuf_size,
+ const uint8_t *buf, int buf_size, int keyframe){
+
+ if(s && s->parser->split){
+ if((avctx->flags & CODEC_FLAG_GLOBAL_HEADER) || (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER)){
+ int i= s->parser->split(avctx, buf, buf_size);
+ buf += i;
+ buf_size -= i;
+ }
+ }
+
+ /* cast to avoid warning about discarding qualifiers */
+ *poutbuf= (uint8_t *) buf;
+ *poutbuf_size= buf_size;
+ if(avctx->extradata){
+ if( (keyframe && (avctx->flags2 & CODEC_FLAG2_LOCAL_HEADER))
+ /*||(s->pict_type != I_TYPE && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_NOKEY))*/
+ /*||(? && (s->flags & PARSER_FLAG_DUMP_EXTRADATA_AT_BEGIN)*/){
+ int size= buf_size + avctx->extradata_size;
+ *poutbuf_size= size;
+ *poutbuf= av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
+
+ memcpy(*poutbuf, avctx->extradata, avctx->extradata_size);
+ memcpy((*poutbuf) + avctx->extradata_size, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
void av_parser_close(AVCodecParserContext *s)
{
if (s->parser->parser_close)
//#define END_NOT_FOUND (-100)
-#define PICTURE_START_CODE 0x00000100
-#define SEQ_START_CODE 0x000001b3
-#define EXT_START_CODE 0x000001b5
-#define SLICE_MIN_START_CODE 0x00000101
-#define SLICE_MAX_START_CODE 0x000001af
+#define PICTURE_START_CODE 0x00000100
+#define SEQ_START_CODE 0x000001b3
+#define EXT_START_CODE 0x000001b5
+#define SLICE_MIN_START_CODE 0x00000101
+#define SLICE_MAX_START_CODE 0x000001af
typedef struct ParseContext1{
ParseContext pc;
for(; pc->overread>0; pc->overread--){
pc->buffer[pc->index++]= pc->buffer[pc->overread_index++];
}
-
+
+ /* flush remaining if EOF */
+ if(!*buf_size && next == END_NOT_FOUND){
+ next= 0;
+ }
+
pc->last_index= pc->index;
/* copy into buffer end return */
*buf_size=
pc->overread_index= pc->index + next;
-
+
/* append to buffer */
if(pc->index){
pc->buffer= av_fast_realloc(pc->buffer, &pc->buffer_size, next + pc->index + FF_INPUT_BUFFER_PADDING_SIZE);
return 0;
}
-static int find_start_code(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
-{
- const uint8_t *buf_ptr;
- unsigned int state=0xFFFFFFFF, v;
- int val;
-
- buf_ptr = *pbuf_ptr;
- while (buf_ptr < buf_end) {
- v = *buf_ptr++;
- if (state == 0x000001) {
- state = ((state << 8) | v) & 0xffffff;
- val = state;
- goto found;
- }
- state = ((state << 8) | v) & 0xffffff;
- }
- val = -1;
- found:
- *pbuf_ptr = buf_ptr;
- return val;
-}
-
/* XXX: merge with libavcodec ? */
#define MPEG1_FRAME_RATE_BASE 1001
static const int frame_rate_tab[16] = {
- 0,
+ 0,
24000,
24024,
25025,
25025,
};
-static void mpegvideo_extract_headers(AVCodecParserContext *s,
+//FIXME move into mpeg12.c
+static void mpegvideo_extract_headers(AVCodecParserContext *s,
AVCodecContext *avctx,
const uint8_t *buf, int buf_size)
{
int32_t start_code;
int frame_rate_index, ext_type, bytes_left;
int frame_rate_ext_n, frame_rate_ext_d;
- int top_field_first, repeat_first_field, progressive_frame;
- int horiz_size_ext, vert_size_ext;
-
+ int picture_structure, top_field_first, repeat_first_field, progressive_frame;
+ int horiz_size_ext, vert_size_ext, bit_rate_ext;
+//FIXME replace the crap with get_bits()
s->repeat_pict = 0;
buf_end = buf + buf_size;
while (buf < buf_end) {
- start_code = find_start_code(&buf, buf_end);
+ start_code= -1;
+ buf= ff_find_start_code(buf, buf_end, &start_code);
bytes_left = buf_end - buf;
switch(start_code) {
case PICTURE_START_CODE:
}
break;
case SEQ_START_CODE:
- if (bytes_left >= 4) {
- pc->width = avctx->width = (buf[0] << 4) | (buf[1] >> 4);
- pc->height = avctx->height = ((buf[1] & 0x0f) << 8) | buf[2];
+ if (bytes_left >= 7) {
+ pc->width = (buf[0] << 4) | (buf[1] >> 4);
+ pc->height = ((buf[1] & 0x0f) << 8) | buf[2];
+ avcodec_set_dimensions(avctx, pc->width, pc->height);
frame_rate_index = buf[3] & 0xf;
- pc->frame_rate = avctx->frame_rate = frame_rate_tab[frame_rate_index];
- avctx->frame_rate_base = MPEG1_FRAME_RATE_BASE;
+ pc->frame_rate = avctx->time_base.den = frame_rate_tab[frame_rate_index];
+ avctx->time_base.num = MPEG1_FRAME_RATE_BASE;
+ avctx->bit_rate = ((buf[4]<<10) | (buf[5]<<2) | (buf[6]>>6))*400;
avctx->codec_id = CODEC_ID_MPEG1VIDEO;
avctx->sub_id = 1;
}
if (bytes_left >= 6) {
horiz_size_ext = ((buf[1] & 1) << 1) | (buf[2] >> 7);
vert_size_ext = (buf[2] >> 5) & 3;
+ bit_rate_ext = ((buf[2] & 0x1F)<<7) | (buf[3]>>1);
frame_rate_ext_n = (buf[5] >> 5) & 3;
frame_rate_ext_d = (buf[5] & 0x1f);
pc->progressive_sequence = buf[1] & (1 << 3);
-
- avctx->width = pc->width | (horiz_size_ext << 12);
- avctx->height = pc->height | (vert_size_ext << 12);
- avctx->frame_rate = pc->frame_rate * (frame_rate_ext_n + 1);
- avctx->frame_rate_base = MPEG1_FRAME_RATE_BASE * (frame_rate_ext_d + 1);
+ avctx->has_b_frames= !(buf[5] >> 7);
+
+ pc->width |=(horiz_size_ext << 12);
+ pc->height |=( vert_size_ext << 12);
+ avctx->bit_rate += (bit_rate_ext << 18) * 400;
+ avcodec_set_dimensions(avctx, pc->width, pc->height);
+ avctx->time_base.den = pc->frame_rate * (frame_rate_ext_n + 1);
+ avctx->time_base.num = MPEG1_FRAME_RATE_BASE * (frame_rate_ext_d + 1);
avctx->codec_id = CODEC_ID_MPEG2VIDEO;
avctx->sub_id = 2; /* forces MPEG2 */
}
break;
case 0x8: /* picture coding extension */
if (bytes_left >= 5) {
+ picture_structure = buf[2]&3;
top_field_first = buf[3] & (1 << 7);
repeat_first_field = buf[3] & (1 << 1);
progressive_frame = buf[4] & (1 << 7);
-
+
/* check if we must repeat the frame */
if (repeat_first_field) {
if (pc->progressive_sequence) {
s->repeat_pict = 1;
}
}
+
+ /* the packet only represents half a frame
+ XXX,FIXME maybe find a different solution */
+ if(picture_structure != 3)
+ s->repeat_pict = -1;
}
break;
}
default:
/* we stop parsing when we encounter a slice. It ensures
that this function takes a negligible amount of time */
- if (start_code >= SLICE_MIN_START_CODE &&
+ if (start_code >= SLICE_MIN_START_CODE &&
start_code <= SLICE_MAX_START_CODE)
goto the_end;
break;
static int mpegvideo_parse(AVCodecParserContext *s,
AVCodecContext *avctx,
- uint8_t **poutbuf, int *poutbuf_size,
+ uint8_t **poutbuf, int *poutbuf_size,
const uint8_t *buf, int buf_size)
{
ParseContext1 *pc1 = s->priv_data;
ParseContext *pc= &pc1->pc;
int next;
-
- next= ff_mpeg1_find_frame_end(pc, buf, buf_size);
-
- if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
- *poutbuf = NULL;
- *poutbuf_size = 0;
- return buf_size;
+
+ if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
+ next= buf_size;
+ }else{
+ next= ff_mpeg1_find_frame_end(pc, buf, buf_size);
+
+ if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
+ *poutbuf = NULL;
+ *poutbuf_size = 0;
+ return buf_size;
+ }
+
}
/* we have a full frame : we just parse the first few MPEG headers
to have the full timing information. The time take by this
function should be negligible for uncorrupted streams */
mpegvideo_extract_headers(s, avctx, buf, buf_size);
#if 0
- printf("pict_type=%d frame_rate=%0.3f repeat_pict=%d\n",
- s->pict_type, (double)avctx->frame_rate / avctx->frame_rate_base, s->repeat_pict);
+ printf("pict_type=%d frame_rate=%0.3f repeat_pict=%d\n",
+ s->pict_type, (double)avctx->time_base.den / avctx->time_base.num, s->repeat_pict);
#endif
*poutbuf = (uint8_t *)buf;
return next;
}
+static int mpegvideo_split(AVCodecContext *avctx,
+ const uint8_t *buf, int buf_size)
+{
+ int i;
+ uint32_t state= -1;
+
+ for(i=0; i<buf_size; i++){
+ state= (state<<8) | buf[i];
+ if(state != 0x1B3 && state != 0x1B5 && state < 0x200 && state >= 0x100)
+ return i-3;
+ }
+ return 0;
+}
+
void ff_parse_close(AVCodecParserContext *s)
{
ParseContext *pc = s->priv_data;
/* used by parser */
/* XXX: make it use less memory */
-static int av_mpeg4_decode_header(AVCodecParserContext *s1,
+static int av_mpeg4_decode_header(AVCodecParserContext *s1,
AVCodecContext *avctx,
const uint8_t *buf, int buf_size)
{
init_get_bits(gb, buf, 8 * buf_size);
ret = ff_mpeg4_decode_picture_header(s, gb);
if (s->width) {
- avctx->width = s->width;
- avctx->height = s->height;
+ avcodec_set_dimensions(avctx, s->width, s->height);
}
+ s1->pict_type= s->pict_type;
pc->first_picture = 0;
return ret;
}
static int mpeg4video_parse(AVCodecParserContext *s,
AVCodecContext *avctx,
- uint8_t **poutbuf, int *poutbuf_size,
+ uint8_t **poutbuf, int *poutbuf_size,
const uint8_t *buf, int buf_size)
{
ParseContext *pc = s->priv_data;
int next;
-
- next= ff_mpeg4_find_frame_end(pc, buf, buf_size);
- if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
- *poutbuf = NULL;
- *poutbuf_size = 0;
- return buf_size;
+ if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
+ next= buf_size;
+ }else{
+ next= ff_mpeg4_find_frame_end(pc, buf, buf_size);
+
+ if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
+ *poutbuf = NULL;
+ *poutbuf_size = 0;
+ return buf_size;
+ }
}
av_mpeg4_decode_header(s, avctx, buf, buf_size);
return next;
}
+static int cavsvideo_parse(AVCodecParserContext *s,
+ AVCodecContext *avctx,
+ uint8_t **poutbuf, int *poutbuf_size,
+ const uint8_t *buf, int buf_size)
+{
+ ParseContext *pc = s->priv_data;
+ int next;
+
+ if(s->flags & PARSER_FLAG_COMPLETE_FRAMES){
+ next= buf_size;
+ }else{
+ next= ff_cavs_find_frame_end(pc, buf, buf_size);
+
+ if (ff_combine_frame(pc, next, (uint8_t **)&buf, &buf_size) < 0) {
+ *poutbuf = NULL;
+ *poutbuf_size = 0;
+ return buf_size;
+ }
+ }
+ *poutbuf = (uint8_t *)buf;
+ *poutbuf_size = buf_size;
+ return next;
+}
+
+static int mpeg4video_split(AVCodecContext *avctx,
+ const uint8_t *buf, int buf_size)
+{
+ int i;
+ uint32_t state= -1;
+
+ for(i=0; i<buf_size; i++){
+ state= (state<<8) | buf[i];
+ if(state == 0x1B3 || state == 0x1B6)
+ return i-3;
+ }
+ return 0;
+}
+
/*************************/
typedef struct MpegAudioParseContext {
- uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE]; /* input buffer */
+ uint8_t inbuf[MPA_MAX_CODED_FRAME_SIZE]; /* input buffer */
uint8_t *inbuf_ptr;
int frame_size;
int free_format_frame_size;
int free_format_next_header;
+ uint32_t header;
+ int header_count;
} MpegAudioParseContext;
#define MPA_HEADER_SIZE 4
/* header + layer + bitrate + freq + lsf/mpeg25 */
+#undef SAME_HEADER_MASK /* mpegaudio.h defines different version */
#define SAME_HEADER_MASK \
- (0xffe00000 | (3 << 17) | (0xf << 12) | (3 << 10) | (3 << 19))
+ (0xffe00000 | (3 << 17) | (3 << 10) | (3 << 19))
static int mpegaudio_parse_init(AVCodecParserContext *s1)
{
static int mpegaudio_parse(AVCodecParserContext *s1,
AVCodecContext *avctx,
- uint8_t **poutbuf, int *poutbuf_size,
+ uint8_t **poutbuf, int *poutbuf_size,
const uint8_t *buf, int buf_size)
{
MpegAudioParseContext *s = s1->priv_data;
- int len, ret;
+ int len, ret, sr;
uint32_t header;
const uint8_t *buf_ptr;
*poutbuf_size = 0;
buf_ptr = buf;
while (buf_size > 0) {
- len = s->inbuf_ptr - s->inbuf;
- if (s->frame_size == 0) {
+ len = s->inbuf_ptr - s->inbuf;
+ if (s->frame_size == 0) {
/* special case for next header for first frame in free
format case (XXX: find a simpler method) */
if (s->free_format_next_header != 0) {
s->free_format_next_header = 0;
goto got_header;
}
- /* no header seen : find one. We need at least MPA_HEADER_SIZE
+ /* no header seen : find one. We need at least MPA_HEADER_SIZE
bytes to parse it */
- len = MPA_HEADER_SIZE - len;
- if (len > buf_size)
- len = buf_size;
- if (len > 0) {
- memcpy(s->inbuf_ptr, buf_ptr, len);
- buf_ptr += len;
- buf_size -= len;
- s->inbuf_ptr += len;
- }
- if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
+ len = MPA_HEADER_SIZE - len;
+ if (len > buf_size)
+ len = buf_size;
+ if (len > 0) {
+ memcpy(s->inbuf_ptr, buf_ptr, len);
+ buf_ptr += len;
+ buf_size -= len;
+ s->inbuf_ptr += len;
+ }
+ if ((s->inbuf_ptr - s->inbuf) >= MPA_HEADER_SIZE) {
got_header:
- header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
- (s->inbuf[2] << 8) | s->inbuf[3];
+ sr= avctx->sample_rate;
+ header = (s->inbuf[0] << 24) | (s->inbuf[1] << 16) |
+ (s->inbuf[2] << 8) | s->inbuf[3];
ret = mpa_decode_header(avctx, header);
if (ret < 0) {
- /* no sync found : move by one byte (inefficient, but simple!) */
- memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
- s->inbuf_ptr--;
+ s->header_count= -2;
+ /* no sync found : move by one byte (inefficient, but simple!) */
+ memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
+ s->inbuf_ptr--;
dprintf("skip %x\n", header);
/* reset free format frame size to give a chance
to get a new bitrate */
s->free_format_frame_size = 0;
- } else {
+ } else {
+ if((header&SAME_HEADER_MASK) != (s->header&SAME_HEADER_MASK) && s->header)
+ s->header_count= -3;
+ s->header= header;
+ s->header_count++;
s->frame_size = ret;
+
#if 0
/* free format: prepare to compute frame size */
- if (decode_header(s, header) == 1) {
- s->frame_size = -1;
+ if (decode_header(s, header) == 1) {
+ s->frame_size = -1;
}
#endif
- }
- }
- } else
+ }
+ if(s->header_count <= 0)
+ avctx->sample_rate= sr; //FIXME ugly
+ }
+ } else
#if 0
if (s->frame_size == -1) {
/* free format : find next sync to compute frame size */
- len = MPA_MAX_CODED_FRAME_SIZE - len;
- if (len > buf_size)
- len = buf_size;
+ len = MPA_MAX_CODED_FRAME_SIZE - len;
+ if (len > buf_size)
+ len = buf_size;
if (len == 0) {
- /* frame too long: resync */
+ /* frame too long: resync */
s->frame_size = 0;
- memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
- s->inbuf_ptr--;
+ memmove(s->inbuf, s->inbuf + 1, s->inbuf_ptr - s->inbuf - 1);
+ s->inbuf_ptr--;
} else {
uint8_t *p, *pend;
uint32_t header1;
s->free_format_frame_size -= padding * 4;
else
s->free_format_frame_size -= padding;
- dprintf("free frame size=%d padding=%d\n",
+ dprintf("free frame size=%d padding=%d\n",
s->free_format_frame_size, padding);
decode_header(s, header1);
goto next_data;
s->inbuf_ptr += len;
buf_size -= len;
}
- } else
+ } else
#endif
if (len < s->frame_size) {
if (s->frame_size > MPA_MAX_CODED_FRAME_SIZE)
s->frame_size = MPA_MAX_CODED_FRAME_SIZE;
- len = s->frame_size - len;
- if (len > buf_size)
- len = buf_size;
- memcpy(s->inbuf_ptr, buf_ptr, len);
- buf_ptr += len;
- s->inbuf_ptr += len;
- buf_size -= len;
- }
+ len = s->frame_size - len;
+ if (len > buf_size)
+ len = buf_size;
+ memcpy(s->inbuf_ptr, buf_ptr, len);
+ buf_ptr += len;
+ s->inbuf_ptr += len;
+ buf_size -= len;
+ }
// next_data:
- if (s->frame_size > 0 &&
+ if (s->frame_size > 0 &&
(s->inbuf_ptr - s->inbuf) >= s->frame_size) {
- *poutbuf = s->inbuf;
- *poutbuf_size = s->inbuf_ptr - s->inbuf;
- s->inbuf_ptr = s->inbuf;
- s->frame_size = 0;
- break;
- }
+ if(s->header_count > 0){
+ *poutbuf = s->inbuf;
+ *poutbuf_size = s->inbuf_ptr - s->inbuf;
+ }
+ s->inbuf_ptr = s->inbuf;
+ s->frame_size = 0;
+ break;
+ }
}
return buf_ptr - buf;
}
-#ifdef CONFIG_AC3
-extern int a52_syncinfo (const uint8_t * buf, int * flags,
- int * sample_rate, int * bit_rate);
-
+/* also used for ADTS AAC */
typedef struct AC3ParseContext {
- uint8_t inbuf[4096]; /* input buffer */
uint8_t *inbuf_ptr;
int frame_size;
- int flags;
+ int header_size;
+ int (*sync)(const uint8_t *buf, int *channels, int *sample_rate,
+ int *bit_rate, int *samples);
+ uint8_t inbuf[8192]; /* input buffer */
} AC3ParseContext;
#define AC3_HEADER_SIZE 7
-#define A52_LFE 16
+#define AAC_HEADER_SIZE 7
+
+static const int ac3_sample_rates[4] = {
+ 48000, 44100, 32000, 0
+};
+
+static const int ac3_frame_sizes[64][3] = {
+ { 64, 69, 96 },
+ { 64, 70, 96 },
+ { 80, 87, 120 },
+ { 80, 88, 120 },
+ { 96, 104, 144 },
+ { 96, 105, 144 },
+ { 112, 121, 168 },
+ { 112, 122, 168 },
+ { 128, 139, 192 },
+ { 128, 140, 192 },
+ { 160, 174, 240 },
+ { 160, 175, 240 },
+ { 192, 208, 288 },
+ { 192, 209, 288 },
+ { 224, 243, 336 },
+ { 224, 244, 336 },
+ { 256, 278, 384 },
+ { 256, 279, 384 },
+ { 320, 348, 480 },
+ { 320, 349, 480 },
+ { 384, 417, 576 },
+ { 384, 418, 576 },
+ { 448, 487, 672 },
+ { 448, 488, 672 },
+ { 512, 557, 768 },
+ { 512, 558, 768 },
+ { 640, 696, 960 },
+ { 640, 697, 960 },
+ { 768, 835, 1152 },
+ { 768, 836, 1152 },
+ { 896, 975, 1344 },
+ { 896, 976, 1344 },
+ { 1024, 1114, 1536 },
+ { 1024, 1115, 1536 },
+ { 1152, 1253, 1728 },
+ { 1152, 1254, 1728 },
+ { 1280, 1393, 1920 },
+ { 1280, 1394, 1920 },
+};
+
+static const int ac3_bitrates[64] = {
+ 32, 32, 40, 40, 48, 48, 56, 56, 64, 64, 80, 80, 96, 96, 112, 112,
+ 128, 128, 160, 160, 192, 192, 224, 224, 256, 256, 320, 320, 384,
+ 384, 448, 448, 512, 512, 576, 576, 640, 640,
+};
+
+static const int ac3_channels[8] = {
+ 2, 1, 2, 3, 3, 4, 4, 5
+};
+
+static int aac_sample_rates[16] = {
+ 96000, 88200, 64000, 48000, 44100, 32000,
+ 24000, 22050, 16000, 12000, 11025, 8000, 7350
+};
+
+static int aac_channels[8] = {
+ 0, 1, 2, 3, 4, 5, 6, 8
+};
+
+static int ac3_sync(const uint8_t *buf, int *channels, int *sample_rate,
+ int *bit_rate, int *samples)
+{
+ unsigned int fscod, frmsizecod, acmod, bsid, lfeon;
+ GetBitContext bits;
+
+ init_get_bits(&bits, buf, AC3_HEADER_SIZE * 8);
+
+ if(get_bits(&bits, 16) != 0x0b77)
+ return 0;
+
+ skip_bits(&bits, 16); /* crc */
+ fscod = get_bits(&bits, 2);
+ frmsizecod = get_bits(&bits, 6);
+
+ if(!ac3_sample_rates[fscod])
+ return 0;
+
+ bsid = get_bits(&bits, 5);
+ if(bsid > 8)
+ return 0;
+ skip_bits(&bits, 3); /* bsmod */
+ acmod = get_bits(&bits, 3);
+ if(acmod & 1 && acmod != 1)
+ skip_bits(&bits, 2); /* cmixlev */
+ if(acmod & 4)
+ skip_bits(&bits, 2); /* surmixlev */
+ if(acmod & 2)
+ skip_bits(&bits, 2); /* dsurmod */
+ lfeon = get_bits1(&bits);
+
+ *sample_rate = ac3_sample_rates[fscod];
+ *bit_rate = ac3_bitrates[frmsizecod] * 1000;
+ *channels = ac3_channels[acmod] + lfeon;
+ *samples = 6 * 256;
+
+ return ac3_frame_sizes[frmsizecod][fscod] * 2;
+}
+
+static int aac_sync(const uint8_t *buf, int *channels, int *sample_rate,
+ int *bit_rate, int *samples)
+{
+ GetBitContext bits;
+ int size, rdb, ch, sr;
+
+ init_get_bits(&bits, buf, AAC_HEADER_SIZE * 8);
+
+ if(get_bits(&bits, 12) != 0xfff)
+ return 0;
+
+ skip_bits1(&bits); /* id */
+ skip_bits(&bits, 2); /* layer */
+ skip_bits1(&bits); /* protection_absent */
+ skip_bits(&bits, 2); /* profile_objecttype */
+ sr = get_bits(&bits, 4); /* sample_frequency_index */
+ if(!aac_sample_rates[sr])
+ return 0;
+ skip_bits1(&bits); /* private_bit */
+ ch = get_bits(&bits, 3); /* channel_configuration */
+ if(!aac_channels[ch])
+ return 0;
+ skip_bits1(&bits); /* original/copy */
+ skip_bits1(&bits); /* home */
+
+ /* adts_variable_header */
+ skip_bits1(&bits); /* copyright_identification_bit */
+ skip_bits1(&bits); /* copyright_identification_start */
+ size = get_bits(&bits, 13); /* aac_frame_length */
+ skip_bits(&bits, 11); /* adts_buffer_fullness */
+ rdb = get_bits(&bits, 2); /* number_of_raw_data_blocks_in_frame */
+
+ *channels = aac_channels[ch];
+ *sample_rate = aac_sample_rates[sr];
+ *samples = (rdb + 1) * 1024;
+ *bit_rate = size * 8 * *sample_rate / *samples;
+
+ return size;
+}
static int ac3_parse_init(AVCodecParserContext *s1)
{
AC3ParseContext *s = s1->priv_data;
s->inbuf_ptr = s->inbuf;
+ s->header_size = AC3_HEADER_SIZE;
+ s->sync = ac3_sync;
+ return 0;
+}
+
+static int aac_parse_init(AVCodecParserContext *s1)
+{
+ AC3ParseContext *s = s1->priv_data;
+ s->inbuf_ptr = s->inbuf;
+ s->header_size = AAC_HEADER_SIZE;
+ s->sync = aac_sync;
return 0;
}
+/* also used for ADTS AAC */
static int ac3_parse(AVCodecParserContext *s1,
AVCodecContext *avctx,
- uint8_t **poutbuf, int *poutbuf_size,
+ uint8_t **poutbuf, int *poutbuf_size,
const uint8_t *buf, int buf_size)
{
AC3ParseContext *s = s1->priv_data;
const uint8_t *buf_ptr;
- int len, sample_rate, bit_rate;
- static const int ac3_channels[8] = {
- 2, 1, 2, 3, 3, 4, 4, 5
- };
+ int len, sample_rate, bit_rate, channels, samples;
*poutbuf = NULL;
*poutbuf_size = 0;
while (buf_size > 0) {
len = s->inbuf_ptr - s->inbuf;
if (s->frame_size == 0) {
- /* no header seen : find one. We need at least 7 bytes to parse it */
- len = AC3_HEADER_SIZE - len;
- if (len > buf_size)
- len = buf_size;
+ /* no header seen : find one. We need at least s->header_size
+ bytes to parse it */
+ len = FFMIN(s->header_size - len, buf_size);
+
memcpy(s->inbuf_ptr, buf_ptr, len);
buf_ptr += len;
s->inbuf_ptr += len;
buf_size -= len;
- if ((s->inbuf_ptr - s->inbuf) == AC3_HEADER_SIZE) {
- len = a52_syncinfo(s->inbuf, &s->flags, &sample_rate, &bit_rate);
+ if ((s->inbuf_ptr - s->inbuf) == s->header_size) {
+ len = s->sync(s->inbuf, &channels, &sample_rate, &bit_rate,
+ &samples);
if (len == 0) {
/* no sync found : move by one byte (inefficient, but simple!) */
- memmove(s->inbuf, s->inbuf + 1, AC3_HEADER_SIZE - 1);
+ memmove(s->inbuf, s->inbuf + 1, s->header_size - 1);
s->inbuf_ptr--;
} else {
- s->frame_size = len;
+ s->frame_size = len;
/* update codec info */
avctx->sample_rate = sample_rate;
/* set channels,except if the user explicitly requests 1 or 2 channels, XXX/FIXME this is a bit ugly */
- if(avctx->channels!=1 && avctx->channels!=2){
- avctx->channels = ac3_channels[s->flags & 7];
- if (s->flags & A52_LFE)
- avctx->channels++;
+ if(avctx->codec_id == CODEC_ID_AC3){
+ if(avctx->channels!=1 && avctx->channels!=2){
+ avctx->channels = channels;
+ }
+ } else {
+ avctx->channels = channels;
}
- avctx->bit_rate = bit_rate;
- avctx->frame_size = 6 * 256;
+ avctx->bit_rate = bit_rate;
+ avctx->frame_size = samples;
}
}
- } else if (len < s->frame_size) {
- len = s->frame_size - len;
- if (len > buf_size)
- len = buf_size;
+ } else {
+ len = FFMIN(s->frame_size - len, buf_size);
memcpy(s->inbuf_ptr, buf_ptr, len);
buf_ptr += len;
s->inbuf_ptr += len;
buf_size -= len;
- } else {
- *poutbuf = s->inbuf;
- *poutbuf_size = s->frame_size;
- s->inbuf_ptr = s->inbuf;
- s->frame_size = 0;
- break;
+
+ 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;
+ }
}
}
return buf_ptr - buf;
}
-#endif
AVCodecParser mpegvideo_parser = {
{ CODEC_ID_MPEG1VIDEO, CODEC_ID_MPEG2VIDEO },
NULL,
mpegvideo_parse,
parse1_close,
+ mpegvideo_split,
};
AVCodecParser mpeg4video_parser = {
mpeg4video_parse_init,
mpeg4video_parse,
parse1_close,
+ mpeg4video_split,
+};
+
+AVCodecParser cavsvideo_parser = {
+ { CODEC_ID_CAVS },
+ sizeof(ParseContext1),
+ NULL,
+ cavsvideo_parse,
+ parse1_close,
+ mpeg4video_split,
};
AVCodecParser mpegaudio_parser = {
NULL,
};
-#ifdef CONFIG_AC3
AVCodecParser ac3_parser = {
{ CODEC_ID_AC3 },
sizeof(AC3ParseContext),
ac3_parse,
NULL,
};
-#endif
+
+AVCodecParser aac_parser = {
+ { CODEC_ID_AAC },
+ sizeof(AC3ParseContext),
+ aac_parse_init,
+ ac3_parse,
+ NULL,
+};
projects / ffmpeg / blobdiff