1/*
2 * MPEG Audio parser
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
23#include "parser.h"
24#include "mpegaudiodecheader.h"
25#include "libavutil/common.h"
26#include "libavformat/apetag.h" // for APE tag.
27#include "libavformat/id3v1.h" // for ID3v1_TAG_SIZE
28
29typedef struct MpegAudioParseContext {
30    ParseContext pc;
31    int frame_size;
32    uint32_t header;
33    int header_count;
34    int no_bitrate;
35} MpegAudioParseContext;
36
37#define MPA_HEADER_SIZE 4
38
39/* header + layer + freq + lsf/mpeg25 */
40#define SAME_HEADER_MASK \
41   (0xffe00000 | (3 << 17) | (3 << 10) | (3 << 19))
42
43static int mpegaudio_parse(AVCodecParserContext *s1,
44                           AVCodecContext *avctx,
45                           const uint8_t **poutbuf, int *poutbuf_size,
46                           const uint8_t *buf, int buf_size)
47{
48    MpegAudioParseContext *s = s1->priv_data;
49    ParseContext *pc = &s->pc;
50    uint32_t state= pc->state;
51    int i;
52    int next= END_NOT_FOUND;
53    int flush = !buf_size;
54
55    for(i=0; i<buf_size; ){
56        if(s->frame_size){
57            int inc= FFMIN(buf_size - i, s->frame_size);
58            i += inc;
59            s->frame_size -= inc;
60            state = 0;
61
62            if(!s->frame_size){
63                next= i;
64                break;
65            }
66        }else{
67            while(i<buf_size){
68                int ret, sr, channels, bit_rate, frame_size;
69                enum AVCodecID codec_id = avctx->codec_id;
70
71                state= (state<<8) + buf[i++];
72
73                ret = ff_mpa_decode_header(state, &sr, &channels, &frame_size, &bit_rate, &codec_id);
74                if (ret < 4) {
75                    if (i > 4)
76                        s->header_count = -2;
77                } else {
78                    int header_threshold = avctx->codec_id != AV_CODEC_ID_NONE && avctx->codec_id != codec_id;
79                    if((state&SAME_HEADER_MASK) != (s->header&SAME_HEADER_MASK) && s->header)
80                        s->header_count= -3;
81                    s->header= state;
82                    s->header_count++;
83                    s->frame_size = ret-4;
84
85                    if (s->header_count > header_threshold) {
86                        avctx->sample_rate= sr;
87                        av_channel_layout_uninit(&avctx->ch_layout);
88                        av_channel_layout_default(&avctx->ch_layout, channels);
89                        s1->duration      = frame_size;
90                        avctx->codec_id   = codec_id;
91                        if (s->no_bitrate || !avctx->bit_rate) {
92                            s->no_bitrate = 1;
93                            avctx->bit_rate += (bit_rate - avctx->bit_rate) / (s->header_count - header_threshold);
94                        }
95                    }
96
97                    if (s1->flags & PARSER_FLAG_COMPLETE_FRAMES) {
98                        s->frame_size = 0;
99                        next = buf_size;
100                    } else if (codec_id == AV_CODEC_ID_MP3ADU) {
101                        avpriv_report_missing_feature(avctx,
102                            "MP3ADU full parser");
103                        *poutbuf = NULL;
104                        *poutbuf_size = 0;
105                        return buf_size; /* parsers must not return error codes */
106                    }
107
108                    break;
109                }
110            }
111        }
112    }
113
114    pc->state= state;
115    if (ff_combine_frame(pc, next, &buf, &buf_size) < 0) {
116        *poutbuf = NULL;
117        *poutbuf_size = 0;
118        return buf_size;
119    }
120
121    if (flush && buf_size >= ID3v1_TAG_SIZE && memcmp(buf, "TAG", 3) == 0) {
122        *poutbuf = NULL;
123        *poutbuf_size = 0;
124        return next;
125    }
126
127    if (flush && buf_size >= APE_TAG_FOOTER_BYTES && memcmp(buf, APE_TAG_PREAMBLE, 8) == 0) {
128        *poutbuf = NULL;
129        *poutbuf_size = 0;
130        return next;
131    }
132
133    *poutbuf = buf;
134    *poutbuf_size = buf_size;
135    return next;
136}
137
138
139const AVCodecParser ff_mpegaudio_parser = {
140    .codec_ids      = { AV_CODEC_ID_MP1, AV_CODEC_ID_MP2, AV_CODEC_ID_MP3, AV_CODEC_ID_MP3ADU },
141    .priv_data_size = sizeof(MpegAudioParseContext),
142    .parser_parse   = mpegaudio_parse,
143    .parser_close   = ff_parse_close,
144};
145