FFmpeg
av1_parser.c
Go to the documentation of this file.
1 /*
2  * AV1 parser
3  *
4  * Copyright (C) 2018 James Almer <jamrial@gmail.com>
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 "av1_parse.h"
24 #include "cbs.h"
25 #include "cbs_av1.h"
26 #include "parser.h"
27 
28 typedef struct AV1ParseContext {
33 
34 static const enum AVPixelFormat pix_fmts_8bit[2][2] = {
37 };
38 static const enum AVPixelFormat pix_fmts_10bit[2][2] = {
41 };
42 static const enum AVPixelFormat pix_fmts_12bit[2][2] = {
45 };
46 
48  AVCodecContext *avctx,
49  const uint8_t **out_data, int *out_size,
50  const uint8_t *data, int size)
51 {
52  AV1ParseContext *s = ctx->priv_data;
55  int ret;
56 
57  *out_data = data;
58  *out_size = size;
59 
60  ctx->key_frame = -1;
63 
64  s->cbc->log_ctx = avctx;
65 
66  if (avctx->extradata_size && !s->parsed_extradata) {
67  s->parsed_extradata = 1;
68 
69  ret = ff_cbs_read(s->cbc, td, avctx->extradata, avctx->extradata_size);
70  if (ret < 0) {
71  av_log(avctx, AV_LOG_WARNING, "Failed to parse extradata.\n");
72  }
73 
74  ff_cbs_fragment_reset(s->cbc, td);
75  }
76 
77  ret = ff_cbs_read(s->cbc, td, data, size);
78  if (ret < 0) {
79  av_log(avctx, AV_LOG_ERROR, "Failed to parse temporal unit.\n");
80  goto end;
81  }
82 
83  if (!av1->sequence_header) {
84  av_log(avctx, AV_LOG_ERROR, "No sequence header available\n");
85  goto end;
86  }
87 
88  for (int i = 0; i < td->nb_units; i++) {
89  CodedBitstreamUnit *unit = &td->units[i];
90  AV1RawOBU *obu = unit->content;
94  int frame_type;
95 
96  if (unit->type == AV1_OBU_FRAME)
97  frame = &obu->obu.frame.header;
98  else if (unit->type == AV1_OBU_FRAME_HEADER)
99  frame = &obu->obu.frame_header;
100  else
101  continue;
102 
103  if (frame->show_existing_frame) {
105 
106  if (!ref->valid) {
107  av_log(avctx, AV_LOG_ERROR, "Invalid reference frame\n");
108  goto end;
109  }
110 
111  ctx->width = ref->frame_width;
112  ctx->height = ref->frame_height;
113  frame_type = ref->frame_type;
114 
115  ctx->key_frame = 0;
116  } else if (!frame->show_frame) {
117  continue;
118  } else {
119  ctx->width = av1->frame_width;
120  ctx->height = av1->frame_height;
121  frame_type = frame->frame_type;
122 
123  ctx->key_frame = frame_type == AV1_FRAME_KEY;
124  }
125 
126  avctx->profile = seq->seq_profile;
127  avctx->level = seq->seq_level_idx[0];
128 
129  switch (frame_type) {
130  case AV1_FRAME_KEY:
133  break;
134  case AV1_FRAME_INTER:
136  break;
137  case AV1_FRAME_SWITCH:
139  break;
140  }
142 
143  switch (av1->bit_depth) {
144  case 8:
145  ctx->format = color->mono_chrome ? AV_PIX_FMT_GRAY8
146  : pix_fmts_8bit [color->subsampling_x][color->subsampling_y];
147  break;
148  case 10:
149  ctx->format = color->mono_chrome ? AV_PIX_FMT_GRAY10
150  : pix_fmts_10bit[color->subsampling_x][color->subsampling_y];
151  break;
152  case 12:
153  ctx->format = color->mono_chrome ? AV_PIX_FMT_GRAY12
154  : pix_fmts_12bit[color->subsampling_x][color->subsampling_y];
155  break;
156  }
158  }
159 
160 end:
161  ff_cbs_fragment_reset(s->cbc, td);
162 
163  s->cbc->log_ctx = NULL;
164 
165  return size;
166 }
167 
174 };
175 
177 {
178  AV1ParseContext *s = ctx->priv_data;
179  int ret;
180 
181  ret = ff_cbs_init(&s->cbc, AV_CODEC_ID_AV1, NULL);
182  if (ret < 0)
183  return ret;
184 
187 
188  return 0;
189 }
190 
192 {
193  AV1ParseContext *s = ctx->priv_data;
194 
196  ff_cbs_close(&s->cbc);
197 }
198 
200  const uint8_t *buf, int buf_size)
201 {
202  AV1OBU obu;
203  const uint8_t *ptr = buf, *end = buf + buf_size;
204 
205  while (ptr < end) {
206  int len = ff_av1_extract_obu(&obu, ptr, buf_size, avctx);
207  if (len < 0)
208  break;
209 
210  if (obu.type == AV1_OBU_FRAME_HEADER ||
211  obu.type == AV1_OBU_FRAME) {
212  return ptr - buf;
213  }
214  ptr += len;
215  buf_size -= len;
216  }
217 
218  return 0;
219 }
220 
222  .codec_ids = { AV_CODEC_ID_AV1 },
223  .priv_data_size = sizeof(AV1ParseContext),
224  .parser_init = av1_parser_init,
225  .parser_close = av1_parser_close,
226  .parser_parse = av1_parser_parse,
228 };
#define NULL
Definition: coverity.c:32
int nb_units
Number of units in this fragment.
Definition: cbs.h:147
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
uint8_t mono_chrome
Definition: cbs_av1.h:44
int width
Dimensions of the decoded video intended for presentation.
Definition: avcodec.h:5255
int ff_cbs_init(CodedBitstreamContext **ctx_ptr, enum AVCodecID codec_id, void *log_ctx)
Create and initialise a new context for the given codec.
Definition: cbs.c:74
CodedBitstreamUnitType type
Codec-specific type of this unit.
Definition: cbs.h:68
int codec_ids[5]
Definition: avcodec.h:5276
int out_size
Definition: movenc.c:55
static enum AVPixelFormat pix_fmts_10bit[2][2]
Definition: av1_parser.c:38
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:391
int ff_av1_extract_obu(AV1OBU *obu, const uint8_t *buf, int length, void *logctx)
Extract an OBU from a raw bitstream.
Definition: av1_parse.c:29
int profile
profile
Definition: avcodec.h:2898
uint8_t seq_profile
Definition: cbs_av1.h:74
static const CodedBitstreamUnitType decompose_unit_types[]
Definition: av1_parser.c:168
static enum AVPixelFormat pix_fmts_12bit[2][2]
Definition: av1_parser.c:42
Undefined.
Definition: avutil.h:273
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:368
CodedBitstreamFragment temporal_unit
Definition: av1_parser.c:30
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:369
enum AVPictureStructure picture_structure
Indicate whether a picture is coded as a frame, top field or bottom field.
Definition: avcodec.h:5242
uint8_t
#define av_cold
Definition: attributes.h:82
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
uint32_t CodedBitstreamUnitType
The codec-specific type of a bitstream unit.
Definition: cbs.h:43
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1666
Coded bitstream unit structure.
Definition: cbs.h:64
ptrdiff_t size
Definition: opengl_enc.c:100
void * content
Pointer to the decomposed form of this unit.
Definition: cbs.h:101
CodedBitstreamUnit * units
Pointer to an array of units of length nb_units_allocated.
Definition: cbs.h:162
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:392
static int av1_parser_split(AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: av1_parser.c:199
AVCodecParser ff_av1_parser
Definition: av1_parser.c:221
#define av_log(a,...)
static enum AVPixelFormat pix_fmts_8bit[2][2]
Definition: av1_parser.c:34
void ff_cbs_fragment_free(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Free the units array of a fragment in addition to what ff_cbs_fragment_reset does.
Definition: cbs.c:154
int parsed_extradata
Definition: av1_parser.c:31
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define td
Definition: regdef.h:70
union AV1RawOBU::@48 obu
static int av1_parser_parse(AVCodecParserContext *ctx, AVCodecContext *avctx, const uint8_t **out_data, int *out_size, const uint8_t *data, int size)
Definition: av1_parser.c:47
AV1RawFrame frame
Definition: cbs_av1.h:395
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:390
static av_cold int av1_parser_init(AVCodecParserContext *ctx)
Definition: av1_parser.c:176
static void av1_parser_close(AVCodecParserContext *ctx)
Definition: av1_parser.c:191
static char * split(char *message, char delim)
Definition: af_channelmap.c:81
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
AV1RawColorConfig color_config
Definition: cbs_av1.h:128
void * log_ctx
Logging context to be passed to all av_log() calls associated with this context.
Definition: cbs.h:173
uint8_t frame_type
Definition: cbs_av1.h:139
AVFormatContext * ctx
Definition: movenc.c:48
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
#define s(width, name)
Definition: cbs_vp9.c:257
int level
level
Definition: avcodec.h:3018
#define FF_ARRAY_ELEMS(a)
uint8_t subsampling_y
Definition: cbs_av1.h:53
int nb_decompose_unit_types
Length of the decompose_unit_types array.
Definition: cbs.h:201
Coded bitstream fragment structure, combining one or more units.
Definition: cbs.h:116
uint8_t subsampling_x
Definition: cbs_av1.h:52
main external API structure.
Definition: avcodec.h:1565
void * buf
Definition: avisynth_c.h:766
int extradata_size
Definition: avcodec.h:1667
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:387
Switching Predicted.
Definition: avutil.h:279
void ff_cbs_fragment_reset(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Free the units contained in a fragment as well as the fragment&#39;s own data buffer, but not the units a...
Definition: cbs.c:139
Context structure for coded bitstream operations.
Definition: cbs.h:168
AV1ReferenceFrameState ref[AV1_NUM_REF_FRAMES]
Definition: cbs_av1.h:444
int type
Definition: av1_parse.h:48
uint8_t show_existing_frame
Definition: cbs_av1.h:134
CodedBitstreamContext * cbc
Definition: av1_parser.c:29
void ff_cbs_close(CodedBitstreamContext **ctx_ptr)
Close a context and free all internal state.
Definition: cbs.c:113
AV1RawSequenceHeader * sequence_header
Definition: cbs_av1.h:419
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:388
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:394
void * priv_data
Internal codec-specific data.
Definition: cbs.h:189
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
Y , 8bpp.
Definition: pixfmt.h:74
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
CodedBitstreamUnitType * decompose_unit_types
Array of unit types which should be decomposed when reading.
Definition: cbs.h:197
int len
int format
The format of the coded data, corresponds to enum AVPixelFormat for video and for enum AVSampleFormat...
Definition: avcodec.h:5272
AV1RawFrameHeader frame_header
Definition: cbs_av1.h:394
uint8_t show_frame
Definition: cbs_av1.h:140
uint8_t frame_to_show_map_idx
Definition: cbs_av1.h:135
int ff_cbs_read(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, const uint8_t *data, size_t size)
Read a bitstream from a memory region into a fragment, then split into units and decompose.
Definition: cbs.c:266
AV1RawFrameHeader header
Definition: cbs_av1.h:300
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
int key_frame
Set by parser to 1 for key frames and 0 for non-key frames.
Definition: avcodec.h:5157
uint8_t seq_level_idx[AV1_MAX_OPERATING_POINTS]
Definition: cbs_av1.h:87
Predicted.
Definition: avutil.h:275