FFmpeg
h264_sei.c
Go to the documentation of this file.
1 /*
2  * H.26L/H.264/AVC/JVT/14496-10/... SEI decoding
3  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * H.264 / AVC / MPEG-4 part10 SEI decoding.
25  * @author Michael Niedermayer <michaelni@gmx.at>
26  */
27 
28 #include <limits.h>
29 #include <stdio.h>
30 #include <string.h>
31 #include "libavutil/error.h"
32 #include "libavutil/log.h"
33 #include "libavutil/macros.h"
34 #include "libavutil/mem.h"
35 #include "bytestream.h"
36 #include "get_bits.h"
37 #include "golomb.h"
38 #include "h264_ps.h"
39 #include "h264_sei.h"
40 #include "sei.h"
41 
42 #define AVERROR_PS_NOT_FOUND FFERRTAG(0xF8,'?','P','S')
43 
44 static const uint8_t sei_num_clock_ts_table[9] = {
45  1, 1, 1, 2, 2, 3, 3, 2, 3
46 };
47 
49 {
50  h->recovery_point.recovery_frame_cnt = -1;
51 
52  h->picture_timing.dpb_output_delay = 0;
53  h->picture_timing.cpb_removal_delay = -1;
54 
55  h->picture_timing.present = 0;
56  h->buffering_period.present = 0;
57  h->common.frame_packing.present = 0;
58  h->common.film_grain_characteristics.present = 0;
59  h->common.display_orientation.present = 0;
60  h->common.afd.present = 0;
61 
62  ff_h2645_sei_reset(&h->common);
63 }
64 
66  void *logctx)
67 {
68  GetBitContext gb;
69  av_unused int ret;
70 
71  ret = init_get_bits8(&gb, h->payload, h->payload_size_bytes);
72  av_assert1(ret >= 0);
73 
74  if (sps->nal_hrd_parameters_present_flag ||
75  sps->vcl_hrd_parameters_present_flag) {
76  h->cpb_removal_delay = get_bits_long(&gb, sps->cpb_removal_delay_length);
77  h->dpb_output_delay = get_bits_long(&gb, sps->dpb_output_delay_length);
78  }
79  if (sps->pic_struct_present_flag) {
80  unsigned int i, num_clock_ts;
81 
82  h->pic_struct = get_bits(&gb, 4);
83  h->ct_type = 0;
84 
85  if (h->pic_struct > H264_SEI_PIC_STRUCT_FRAME_TRIPLING)
86  return AVERROR_INVALIDDATA;
87 
88  num_clock_ts = sei_num_clock_ts_table[h->pic_struct];
89  h->timecode_cnt = 0;
90  for (i = 0; i < num_clock_ts; i++) {
91  if (get_bits(&gb, 1)) { /* clock_timestamp_flag */
92  H264SEITimeCode *tc = &h->timecode[h->timecode_cnt++];
93  unsigned int full_timestamp_flag;
94  unsigned int counting_type, cnt_dropped_flag;
95  h->ct_type |= 1 << get_bits(&gb, 2);
96  skip_bits(&gb, 1); /* nuit_field_based_flag */
97  counting_type = get_bits(&gb, 5); /* counting_type */
98  full_timestamp_flag = get_bits(&gb, 1);
99  skip_bits(&gb, 1); /* discontinuity_flag */
100  cnt_dropped_flag = get_bits(&gb, 1); /* cnt_dropped_flag */
101  if (cnt_dropped_flag && counting_type > 1 && counting_type < 7)
102  tc->dropframe = 1;
103  tc->frame = get_bits(&gb, 8); /* n_frames */
104  if (full_timestamp_flag) {
105  tc->full = 1;
106  tc->seconds = get_bits(&gb, 6); /* seconds_value 0..59 */
107  tc->minutes = get_bits(&gb, 6); /* minutes_value 0..59 */
108  tc->hours = get_bits(&gb, 5); /* hours_value 0..23 */
109  } else {
110  tc->seconds = tc->minutes = tc->hours = tc->full = 0;
111  if (get_bits(&gb, 1)) { /* seconds_flag */
112  tc->seconds = get_bits(&gb, 6);
113  if (get_bits(&gb, 1)) { /* minutes_flag */
114  tc->minutes = get_bits(&gb, 6);
115  if (get_bits(&gb, 1)) /* hours_flag */
116  tc->hours = get_bits(&gb, 5);
117  }
118  }
119  }
120 
121  if (sps->time_offset_length > 0)
122  skip_bits(&gb,
123  sps->time_offset_length); /* time_offset */
124  }
125  }
126 
127  av_log(logctx, AV_LOG_DEBUG, "ct_type:%X pic_struct:%d\n",
128  h->ct_type, h->pic_struct);
129  }
130 
131  return 0;
132 }
133 
135  void *logctx)
136 {
138 
139  if (size > sizeof(h->payload)) {
140  av_log(logctx, AV_LOG_ERROR, "Picture timing SEI payload too large\n");
141  return AVERROR_INVALIDDATA;
142  }
143  bytestream2_get_bufferu(gb, h->payload, size);
144 
145  h->payload_size_bytes = size;
146 
147  h->present = 1;
148  return 0;
149 }
150 
152 {
153  unsigned recovery_frame_cnt = get_ue_golomb_long(gb);
154 
155  if (recovery_frame_cnt >= (1<<MAX_LOG2_MAX_FRAME_NUM)) {
156  av_log(logctx, AV_LOG_ERROR, "recovery_frame_cnt %u is out of range\n", recovery_frame_cnt);
157  return AVERROR_INVALIDDATA;
158  }
159 
160  h->recovery_frame_cnt = recovery_frame_cnt;
161  /* 1b exact_match_flag,
162  * 1b broken_link_flag,
163  * 2b changing_slice_group_idc */
164  skip_bits(gb, 4);
165 
166  return 0;
167 }
168 
170  const H264ParamSets *ps, void *logctx)
171 {
172  unsigned int sps_id;
173  int sched_sel_idx;
174  const SPS *sps;
175 
176  sps_id = get_ue_golomb_31(gb);
177  if (sps_id > 31 || !ps->sps_list[sps_id]) {
178  av_log(logctx, AV_LOG_ERROR,
179  "non-existing SPS %d referenced in buffering period\n", sps_id);
180  return sps_id > 31 ? AVERROR_INVALIDDATA : AVERROR_PS_NOT_FOUND;
181  }
182  sps = (const SPS*)ps->sps_list[sps_id]->data;
183 
184  // NOTE: This is really so duplicated in the standard... See H.264, D.1.1
185  if (sps->nal_hrd_parameters_present_flag) {
186  for (sched_sel_idx = 0; sched_sel_idx < sps->cpb_cnt; sched_sel_idx++) {
187  h->initial_cpb_removal_delay[sched_sel_idx] =
188  get_bits_long(gb, sps->initial_cpb_removal_delay_length);
189  // initial_cpb_removal_delay_offset
190  skip_bits(gb, sps->initial_cpb_removal_delay_length);
191  }
192  }
193  if (sps->vcl_hrd_parameters_present_flag) {
194  for (sched_sel_idx = 0; sched_sel_idx < sps->cpb_cnt; sched_sel_idx++) {
195  h->initial_cpb_removal_delay[sched_sel_idx] =
196  get_bits_long(gb, sps->initial_cpb_removal_delay_length);
197  // initial_cpb_removal_delay_offset
198  skip_bits(gb, sps->initial_cpb_removal_delay_length);
199  }
200  }
201 
202  h->present = 1;
203  return 0;
204 }
205 
207 {
208  h->green_metadata_type = bytestream2_get_byte(gb);
209 
210  if (h->green_metadata_type == 0) {
211  h->period_type = bytestream2_get_byte(gb);
212 
213  if (h->period_type == 2)
214  h->num_seconds = bytestream2_get_be16(gb);
215  else if (h->period_type == 3)
216  h->num_pictures = bytestream2_get_be16(gb);
217 
218  h->percent_non_zero_macroblocks = bytestream2_get_byte(gb);
219  h->percent_intra_coded_macroblocks = bytestream2_get_byte(gb);
220  h->percent_six_tap_filtering = bytestream2_get_byte(gb);
221  h->percent_alpha_point_deblocking_instance = bytestream2_get_byte(gb);
222 
223  } else if (h->green_metadata_type == 1) {
224  h->xsd_metric_type = bytestream2_get_byte(gb);
225  h->xsd_metric_value = bytestream2_get_be16(gb);
226  }
227 
228  return 0;
229 }
230 
232  const H264ParamSets *ps, void *logctx)
233 {
234  GetByteContext gbyte;
235  int master_ret = 0;
236 
237  av_assert1((get_bits_count(gb) % 8) == 0);
238  bytestream2_init(&gbyte, gb->buffer + get_bits_count(gb) / 8,
239  get_bits_left(gb) / 8);
240 
241  while (bytestream2_get_bytes_left(&gbyte) > 2 && bytestream2_peek_ne16(&gbyte)) {
242  GetByteContext gbyte_payload;
243  GetBitContext gb_payload;
244  int type = 0;
245  unsigned size = 0;
246  int ret = 0;
247 
248  do {
249  if (bytestream2_get_bytes_left(&gbyte) <= 0)
250  return AVERROR_INVALIDDATA;
251  type += bytestream2_peek_byteu(&gbyte);
252  } while (bytestream2_get_byteu(&gbyte) == 255);
253 
254  do {
255  if (bytestream2_get_bytes_left(&gbyte) <= 0)
256  return AVERROR_INVALIDDATA;
257  size += bytestream2_peek_byteu(&gbyte);
258  } while (bytestream2_get_byteu(&gbyte) == 255);
259 
260  if (size > bytestream2_get_bytes_left(&gbyte)) {
261  av_log(logctx, AV_LOG_ERROR, "SEI type %d size %d truncated at %d\n",
263  return AVERROR_INVALIDDATA;
264  }
265 
266  bytestream2_init (&gbyte_payload, gbyte.buffer, size);
267  ret = init_get_bits8(&gb_payload, gbyte.buffer, size);
268  if (ret < 0)
269  return ret;
270 
271  switch (type) {
272  case SEI_TYPE_PIC_TIMING: // Picture timing SEI
273  ret = decode_picture_timing(&h->picture_timing, &gbyte_payload, logctx);
274  break;
276  ret = decode_recovery_point(&h->recovery_point, &gb_payload, logctx);
277  break;
279  ret = decode_buffering_period(&h->buffering_period, &gb_payload, ps, logctx);
280  break;
282  ret = decode_green_metadata(&h->green_metadata, &gbyte_payload);
283  break;
284  default:
286  &gb_payload, &gbyte_payload, logctx);
288  av_log(logctx, AV_LOG_DEBUG, "unknown SEI type %d\n", type);
289  }
290  if (ret < 0 && ret != AVERROR_PS_NOT_FOUND)
291  return ret;
292  if (ret < 0)
293  master_ret = ret;
294 
295  if (get_bits_left(&gb_payload) < 0) {
296  av_log(logctx, AV_LOG_WARNING, "SEI type %d overread by %d bits\n",
297  type, -get_bits_left(&gb_payload));
298  }
299 
300  bytestream2_skipu(&gbyte, size);
301  }
302 
303  return master_ret;
304 }
305 
307 {
308  if (h->arrangement_cancel_flag == 0) {
309  switch (h->arrangement_type) {
311  if (h->content_interpretation_type == 2)
312  return "checkerboard_rl";
313  else
314  return "checkerboard_lr";
316  if (h->content_interpretation_type == 2)
317  return "col_interleaved_rl";
318  else
319  return "col_interleaved_lr";
321  if (h->content_interpretation_type == 2)
322  return "row_interleaved_rl";
323  else
324  return "row_interleaved_lr";
326  if (h->content_interpretation_type == 2)
327  return "right_left";
328  else
329  return "left_right";
331  if (h->content_interpretation_type == 2)
332  return "bottom_top";
333  else
334  return "top_bottom";
336  if (h->content_interpretation_type == 2)
337  return "block_rl";
338  else
339  return "block_lr";
341  default:
342  return "mono";
343  }
344  } else if (h->arrangement_cancel_flag == 1) {
345  return "mono";
346  } else {
347  return NULL;
348  }
349 }
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVERROR_PS_NOT_FOUND
#define AVERROR_PS_NOT_FOUND
Definition: h264_sei.c:42
ff_h264_sei_uninit
void ff_h264_sei_uninit(H264SEIContext *h)
Reset SEI values at the beginning of the frame.
Definition: h264_sei.c:48
bytestream2_peek_ne16
#define bytestream2_peek_ne16
Definition: bytestream.h:131
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:839
SEI_FPA_H264_TYPE_CHECKERBOARD
@ SEI_FPA_H264_TYPE_CHECKERBOARD
Definition: sei.h:148
SEI_FPA_TYPE_INTERLEAVE_TEMPORAL
@ SEI_FPA_TYPE_INTERLEAVE_TEMPORAL
Definition: sei.h:153
H2645SEIFramePacking
Definition: h2645_sei.h:57
GetByteContext
Definition: bytestream.h:33
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
bytestream2_skipu
static av_always_inline void bytestream2_skipu(GetByteContext *g, unsigned int size)
Definition: bytestream.h:174
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
av_unused
#define av_unused
Definition: attributes.h:131
SEI_FPA_TYPE_TOP_BOTTOM
@ SEI_FPA_TYPE_TOP_BOTTOM
Definition: sei.h:152
decode_green_metadata
static int decode_green_metadata(H264SEIGreenMetaData *h, GetByteContext *gb)
Definition: h264_sei.c:206
ff_h2645_sei_message_decode
int ff_h2645_sei_message_decode(H2645SEI *h, enum SEIType type, enum AVCodecID codec_id, GetBitContext *gb, GetByteContext *gbyte, void *logctx)
Decode a single SEI message.
Definition: h2645_sei.c:369
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
golomb.h
exp golomb vlc stuff
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
sei_num_clock_ts_table
static const uint8_t sei_num_clock_ts_table[9]
Definition: h264_sei.c:44
SEI_FPA_H264_TYPE_INTERLEAVE_COLUMN
@ SEI_FPA_H264_TYPE_INTERLEAVE_COLUMN
Definition: sei.h:149
macros.h
ff_h264_sei_decode
int ff_h264_sei_decode(H264SEIContext *h, GetBitContext *gb, const H264ParamSets *ps, void *logctx)
Definition: h264_sei.c:231
GetBitContext
Definition: get_bits.h:61
decode_recovery_point
static int decode_recovery_point(H264SEIRecoveryPoint *h, GetBitContext *gb, void *logctx)
Definition: h264_sei.c:151
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
ff_h264_sei_process_picture_timing
int ff_h264_sei_process_picture_timing(H264SEIPictureTiming *h, const SPS *sps, void *logctx)
Parse the contents of a picture timing message given an active SPS.
Definition: h264_sei.c:65
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:667
SEI_FPA_H264_TYPE_INTERLEAVE_ROW
@ SEI_FPA_H264_TYPE_INTERLEAVE_ROW
Definition: sei.h:150
GetByteContext::buffer
const uint8_t * buffer
Definition: bytestream.h:34
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
get_bits.h
limits.h
H264ParamSets::sps_list
AVBufferRef * sps_list[MAX_SPS_COUNT]
Definition: h264_ps.h:138
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
if
if(ret)
Definition: filter_design.txt:179
GetBitContext::buffer
const uint8_t * buffer
Definition: get_bits.h:62
NULL
#define NULL
Definition: coverity.c:32
H264SEIContext
Definition: h264_sei.h:119
SPS
Sequence parameter set.
Definition: h264_ps.h:45
FF_H2645_SEI_MESSAGE_UNHANDLED
@ FF_H2645_SEI_MESSAGE_UNHANDLED
Definition: h2645_sei.h:115
sei.h
H264SEIGreenMetaData
Definition: h264_sei.h:106
SEI_TYPE_GREEN_METADATA
@ SEI_TYPE_GREEN_METADATA
Definition: sei.h:85
H264SEIRecoveryPoint
Definition: h264_sei.h:90
h264_ps.h
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
error.h
H264SEIPictureTiming
Definition: h264_sei.h:54
size
int size
Definition: twinvq_data.h:10344
MAX_LOG2_MAX_FRAME_NUM
#define MAX_LOG2_MAX_FRAME_NUM
Definition: h264_ps.h:40
SEI_FPA_TYPE_SIDE_BY_SIDE
@ SEI_FPA_TYPE_SIDE_BY_SIDE
Definition: sei.h:151
ff_h2645_sei_reset
void ff_h2645_sei_reset(H2645SEI *s)
Definition: h2645_sei.c:615
H264_SEI_PIC_STRUCT_FRAME_TRIPLING
@ H264_SEI_PIC_STRUCT_FRAME_TRIPLING
8: frame tripling
Definition: h264_sei.h:40
h264_sei.h
SEI_FPA_H264_TYPE_2D
@ SEI_FPA_H264_TYPE_2D
Definition: sei.h:154
decode_picture_timing
static int decode_picture_timing(H264SEIPictureTiming *h, GetByteContext *gb, void *logctx)
Definition: h264_sei.c:134
log.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
H264SEITimeCode
Definition: h264_sei.h:43
SEI_TYPE_PIC_TIMING
@ SEI_TYPE_PIC_TIMING
Definition: sei.h:31
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
H264SEIBufferingPeriod
Definition: h264_sei.h:101
ret
ret
Definition: filter_design.txt:187
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
Definition: cbs_h264_syntax_template.c:260
get_ue_golomb_31
static int get_ue_golomb_31(GetBitContext *gb)
read unsigned exp golomb code, constraint to a max of 31.
Definition: golomb.h:120
SEI_TYPE_BUFFERING_PERIOD
@ SEI_TYPE_BUFFERING_PERIOD
Definition: sei.h:30
H264ParamSets
Definition: h264_ps.h:137
SEI_TYPE_RECOVERY_POINT
@ SEI_TYPE_RECOVERY_POINT
Definition: sei.h:36
tc
#define tc
Definition: regdef.h:69
mem.h
bytestream2_get_bufferu
static av_always_inline unsigned int bytestream2_get_bufferu(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:277
get_ue_golomb_long
static unsigned get_ue_golomb_long(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to UINT32_MAX-1.
Definition: golomb.h:104
ff_h264_sei_stereo_mode
const char * ff_h264_sei_stereo_mode(const H2645SEIFramePacking *h)
Get stereo_mode string from the h264 frame_packing_arrangement.
Definition: h264_sei.c:306
decode_buffering_period
static int decode_buffering_period(H264SEIBufferingPeriod *h, GetBitContext *gb, const H264ParamSets *ps, void *logctx)
Definition: h264_sei.c:169
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
h
h
Definition: vp9dsp_template.c:2038