FFmpeg: libavcodec/opus/parser.c Source File

FFmpeg
parser.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2013-2014 Mozilla Corporation
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg 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.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg 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 FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 /**
22  * @file
23  * Opus parser
24  *
25  * Determines the duration for each packet.
26  */
27 
28 #include "libavutil/mem.h"
29 #include "avcodec.h"
30 #include "bytestream.h"
31 #include "opus.h"
32 #include "parse.h"
33 #include "parser.h"
34 #include "parser_internal.h"
35 
36  typedef struct OpusParserContext {
37   ParseContext pc;
38   OpusParseContext ctx;
39   OpusPacket pkt;
40   int extradata_parsed;
41   int ts_framing;
42 } OpusParserContext;
43 
44  static const uint8_t *parse_opus_ts_header(const uint8_t *start, int *payload_len, int buf_len)
45 {
46  const uint8_t *buf = start + 1;
47  int start_trim_flag, end_trim_flag, control_extension_flag, control_extension_length;
48  uint8_t flags;
49  uint64_t payload_len_tmp;
50 
51  GetByteContext gb;
52  bytestream2_init(&gb, buf, buf_len);
53 
54  flags = bytestream2_get_byte(&gb);
55  start_trim_flag = (flags >> 4) & 1;
56  end_trim_flag = (flags >> 3) & 1;
57  control_extension_flag = (flags >> 2) & 1;
58 
59  payload_len_tmp = *payload_len = 0;
60  while (bytestream2_peek_byte(&gb) == 0xff)
61  payload_len_tmp += bytestream2_get_byte(&gb);
62 
63  payload_len_tmp += bytestream2_get_byte(&gb);
64 
65  if (start_trim_flag)
66  bytestream2_skip(&gb, 2);
67  if (end_trim_flag)
68  bytestream2_skip(&gb, 2);
69  if (control_extension_flag) {
70  control_extension_length = bytestream2_get_byte(&gb);
71  bytestream2_skip(&gb, control_extension_length);
72  }
73 
74  if (bytestream2_tell(&gb) + payload_len_tmp > buf_len)
75  return NULL;
76 
77  *payload_len = payload_len_tmp;
78 
79  return buf + bytestream2_tell(&gb);
80 }
81 
82  static int set_frame_duration(AVCodecParserContext *ctx, AVCodecContext *avctx,
83  const uint8_t *buf, int buf_size)
84 {
85  OpusParserContext *s = ctx->priv_data;
86 
87  if (ff_opus_parse_packet(&s->pkt, buf, buf_size, s->ctx.nb_streams > 1) < 0) {
88  av_log(avctx, AV_LOG_ERROR, "Error parsing Opus packet header.\n");
89  return AVERROR_INVALIDDATA;
90  }
91 
92  ctx->duration = s->pkt.frame_count * s->pkt.frame_duration;
93 
94  return 0;
95 }
96 
97 /**
98  * Find the end of the current frame in the bitstream.
99  * @return the position of the first byte of the next frame, or -1
100  */
101  static int opus_find_frame_end(AVCodecParserContext *ctx, AVCodecContext *avctx,
102  const uint8_t *buf, int buf_size, int *header_len)
103 {
104  OpusParserContext *s = ctx->priv_data;
105  ParseContext *pc = &s->pc;
106  int ret, start_found, i = 0, payload_len = 0;
107  const uint8_t *payload;
108  uint32_t state;
109  uint16_t hdr;
110  *header_len = 0;
111 
112  if (!buf_size)
113  return 0;
114 
115  start_found = pc->frame_start_found;
116  state = pc->state;
117  payload = buf;
118 
119  /* Check if we're using Opus in MPEG-TS framing */
120  if (!s->ts_framing && buf_size > 2) {
121  hdr = AV_RB16(buf);
122  if ((hdr & OPUS_TS_MASK) == OPUS_TS_HEADER)
123  s->ts_framing = 1;
124  }
125 
126  if (s->ts_framing && !start_found) {
127  for (i = 0; i < buf_size-2; i++) {
128  state = (state << 8) | payload[i];
129  if ((state & OPUS_TS_MASK) == OPUS_TS_HEADER) {
130  payload = parse_opus_ts_header(payload, &payload_len, buf_size - i);
131  if (!payload) {
132  av_log(avctx, AV_LOG_ERROR, "Error parsing Ogg TS header.\n");
133  return AVERROR_INVALIDDATA;
134  }
135  *header_len = payload - buf;
136  start_found = 1;
137  break;
138  }
139  }
140  }
141 
142  if (!s->ts_framing)
143  payload_len = buf_size;
144 
145  if (payload_len <= buf_size && (!s->ts_framing || start_found)) {
146  ret = set_frame_duration(ctx, avctx, payload, payload_len);
147  if (ret < 0) {
148  pc->frame_start_found = 0;
149  return AVERROR_INVALIDDATA;
150  }
151  }
152 
153  if (s->ts_framing) {
154  if (start_found) {
155  if (payload_len + *header_len <= buf_size) {
156  pc->frame_start_found = 0;
157  pc->state = -1;
158  return payload_len + *header_len;
159  }
160  }
161 
162  pc->frame_start_found = start_found;
163  pc->state = state;
164  return END_NOT_FOUND;
165  }
166 
167  return buf_size;
168 }
169 
170  static int opus_parse(AVCodecParserContext *ctx, AVCodecContext *avctx,
171  const uint8_t **poutbuf, int *poutbuf_size,
172  const uint8_t *buf, int buf_size)
173 {
174  OpusParserContext *s = ctx->priv_data;
175  ParseContext *pc = &s->pc;
176  int next, header_len = 0;
177 
178  avctx->sample_rate = 48000;
179 
180  if (avctx->extradata && !s->extradata_parsed) {
181  if (ff_opus_parse_extradata(avctx, &s->ctx) < 0) {
182  av_log(avctx, AV_LOG_ERROR, "Error parsing Ogg extradata.\n");
183  goto fail;
184  }
185  av_freep(&s->ctx.channel_maps);
186  s->extradata_parsed = 1;
187  }
188 
189  if (ctx->flags & PARSER_FLAG_COMPLETE_FRAMES) {
190  next = buf_size;
191 
192  if (set_frame_duration(ctx, avctx, buf, buf_size) < 0)
193  goto fail;
194  } else {
195  next = opus_find_frame_end(ctx, avctx, buf, buf_size, &header_len);
196 
197  if (s->ts_framing && next != AVERROR_INVALIDDATA &&
198  ff_combine_frame(pc, next, &buf, &buf_size) < 0) {
199  goto fail;
200  }
201 
202  if (next == AVERROR_INVALIDDATA){
203  goto fail;
204  }
205  }
206 
207  *poutbuf = buf + header_len;
208  *poutbuf_size = buf_size - header_len;
209  return next;
210 
211 fail:
212  *poutbuf = NULL;
213  *poutbuf_size = 0;
214  return buf_size;
215 }
216 
217  const FFCodecParser ff_opus_parser = {
218  PARSER_CODEC_LIST(AV_CODEC_ID_OPUS),
219  .priv_data_size = sizeof(OpusParserContext),
220  .parse = opus_parse,
221  .close = ff_parse_close
222 };
flags
const SwsFlags flags[]
Definition: swscale.c:61
OpusParserContext::extradata_parsed
int extradata_parsed
Definition: parser.c:40
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1024
OPUS_TS_MASK
#define OPUS_TS_MASK
Definition: opus.h:33
GetByteContext
Definition: bytestream.h:33
bytestream2_tell
static av_always_inline int bytestream2_tell(const GetByteContext *g)
Definition: bytestream.h:192
ff_parse_close
av_cold void ff_parse_close(AVCodecParserContext *s)
Definition: parser.c:298
parser_internal.h
parse_opus_ts_header
static const uint8_t * parse_opus_ts_header(const uint8_t *start, int *payload_len, int buf_len)
Definition: parser.c:44
opus.h
OpusParserContext
Definition: parser.c:36
OpusParserContext::ts_framing
int ts_framing
Definition: parser.c:41
ParseContext::state
uint32_t state
contains the last few bytes in MSB order
Definition: parser.h:33
close
static av_cold void close(AVCodecParserContext *s)
Definition: apv_parser.c:136
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
ParseContext
Definition: parser.h:28
fail
#define fail()
Definition: checkasm.h:207
state
static struct @542 state
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
parse.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1415
ff_opus_parse_extradata
av_cold int ff_opus_parse_extradata(AVCodecContext *avctx, OpusParseContext *s)
Definition: parse.c:296
ctx
AVFormatContext * ctx
Definition: movenc.c:49
OpusParserContext::ctx
OpusParseContext ctx
Definition: parser.c:38
ff_opus_parser
const FFCodecParser ff_opus_parser
Definition: parser.c:217
OpusParserContext::pc
ParseContext pc
Definition: parser.c:37
set_frame_duration
static int set_frame_duration(AVCodecParserContext *ctx, AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: parser.c:82
NULL
#define NULL
Definition: coverity.c:32
OPUS_TS_HEADER
#define OPUS_TS_HEADER
Definition: opus.h:32
ParseContext::frame_start_found
int frame_start_found
Definition: parser.h:34
OpusParseContext
Definition: parse.h:63
OpusParserContext::pkt
OpusPacket pkt
Definition: parser.c:39
parse
static int parse(AVCodecParserContext *s, AVCodecContext *avctx, const uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size)
Definition: apv_parser.c:46
AV_CODEC_ID_OPUS
@ AV_CODEC_ID_OPUS
Definition: codec_id.h:519
opus_parse
static int opus_parse(AVCodecParserContext *ctx, AVCodecContext *avctx, const uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size)
Definition: parser.c:170
ff_combine_frame
int ff_combine_frame(ParseContext *pc, int next, const uint8_t **buf, int *buf_size)
Combine the (truncated) bitstream to a complete frame.
Definition: parser.c:211
FFCodecParser
Definition: parser_internal.h:29
PARSER_FLAG_COMPLETE_FRAMES
#define PARSER_FLAG_COMPLETE_FRAMES
Definition: avcodec.h:2609
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
opus_find_frame_end
static int opus_find_frame_end(AVCodecParserContext *ctx, AVCodecContext *avctx, const uint8_t *buf, int buf_size, int *header_len)
Find the end of the current frame in the bitstream.
Definition: parser.c:101
AVCodecContext::extradata
uint8_t * extradata
Out-of-band global headers that may be used by some codecs.
Definition: avcodec.h:514
parser.h
PARSER_CODEC_LIST
#define PARSER_CODEC_LIST(...)
Definition: parser_internal.h:76
avcodec.h
AVCodecParserContext
Definition: avcodec.h:2575
ret
ret
Definition: filter_design.txt:187
AVCodecContext
main external API structure.
Definition: avcodec.h:431
OpusPacket
Definition: parse.h:31
AVFormatContext::duration
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1399
mem.h
END_NOT_FOUND
#define END_NOT_FOUND
Definition: parser.h:40
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
bytestream.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
ff_opus_parse_packet
int ff_opus_parse_packet(OpusPacket *pkt, const uint8_t *buf, int buf_size, int self_delimiting)
Parse Opus packet info from raw packet data.
Definition: parse.c:95
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1292
AV_RB16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:98
Generated on Tue Nov 18 2025 19:22:14 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /