FFmpeg
cbs_mpeg2.c
Go to the documentation of this file.
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18 
19 #include "libavutil/avassert.h"
20 
21 #include "cbs.h"
22 #include "cbs_internal.h"
23 #include "cbs_mpeg2.h"
24 #include "internal.h"
25 
26 
27 #define HEADER(name) do { \
28  ff_cbs_trace_header(ctx, name); \
29  } while (0)
30 
31 #define CHECK(call) do { \
32  err = (call); \
33  if (err < 0) \
34  return err; \
35  } while (0)
36 
37 #define FUNC_NAME(rw, codec, name) cbs_ ## codec ## _ ## rw ## _ ## name
38 #define FUNC_MPEG2(rw, name) FUNC_NAME(rw, mpeg2, name)
39 #define FUNC(name) FUNC_MPEG2(READWRITE, name)
40 
41 #define SUBSCRIPTS(subs, ...) (subs > 0 ? ((int[subs + 1]){ subs, __VA_ARGS__ }) : NULL)
42 
43 #define ui(width, name) \
44  xui(width, name, current->name, 0, MAX_UINT_BITS(width), 0, )
45 #define uir(width, name) \
46  xui(width, name, current->name, 1, MAX_UINT_BITS(width), 0, )
47 #define uis(width, name, subs, ...) \
48  xui(width, name, current->name, 0, MAX_UINT_BITS(width), subs, __VA_ARGS__)
49 #define uirs(width, name, subs, ...) \
50  xui(width, name, current->name, 1, MAX_UINT_BITS(width), subs, __VA_ARGS__)
51 #define xui(width, name, var, range_min, range_max, subs, ...) \
52  xuia(width, #name, var, range_min, range_max, subs, __VA_ARGS__)
53 #define sis(width, name, subs, ...) \
54  xsi(width, name, current->name, subs, __VA_ARGS__)
55 
56 #define marker_bit() \
57  bit("marker_bit", 1)
58 #define bit(string, value) do { \
59  av_unused uint32_t bit = value; \
60  xuia(1, string, bit, value, value, 0, ); \
61  } while (0)
62 
63 
64 #define READ
65 #define READWRITE read
66 #define RWContext GetBitContext
67 
68 #define xuia(width, string, var, range_min, range_max, subs, ...) do { \
69  uint32_t value; \
70  CHECK(ff_cbs_read_unsigned(ctx, rw, width, string, \
71  SUBSCRIPTS(subs, __VA_ARGS__), \
72  &value, range_min, range_max)); \
73  var = value; \
74  } while (0)
75 
76 #define xsi(width, name, var, subs, ...) do { \
77  int32_t value; \
78  CHECK(ff_cbs_read_signed(ctx, rw, width, #name, \
79  SUBSCRIPTS(subs, __VA_ARGS__), &value, \
80  MIN_INT_BITS(width), \
81  MAX_INT_BITS(width))); \
82  var = value; \
83  } while (0)
84 
85 #define nextbits(width, compare, var) \
86  (get_bits_left(rw) >= width && \
87  (var = show_bits(rw, width)) == (compare))
88 
89 #define infer(name, value) do { \
90  current->name = value; \
91  } while (0)
92 
94 
95 #undef READ
96 #undef READWRITE
97 #undef RWContext
98 #undef xuia
99 #undef xsi
100 #undef nextbits
101 #undef infer
102 
103 
104 #define WRITE
105 #define READWRITE write
106 #define RWContext PutBitContext
107 
108 #define xuia(width, string, var, range_min, range_max, subs, ...) do { \
109  CHECK(ff_cbs_write_unsigned(ctx, rw, width, string, \
110  SUBSCRIPTS(subs, __VA_ARGS__), \
111  var, range_min, range_max)); \
112  } while (0)
113 
114 #define xsi(width, name, var, subs, ...) do { \
115  CHECK(ff_cbs_write_signed(ctx, rw, width, #name, \
116  SUBSCRIPTS(subs, __VA_ARGS__), var, \
117  MIN_INT_BITS(width), \
118  MAX_INT_BITS(width))); \
119  } while (0)
120 
121 #define nextbits(width, compare, var) (var)
122 
123 #define infer(name, value) do { \
124  if (current->name != (value)) { \
125  av_log(ctx->log_ctx, AV_LOG_WARNING, "Warning: " \
126  "%s does not match inferred value: " \
127  "%"PRId64", but should be %"PRId64".\n", \
128  #name, (int64_t)current->name, (int64_t)(value)); \
129  } \
130  } while (0)
131 
133 
134 #undef WRITE
135 #undef READWRITE
136 #undef RWContext
137 #undef xuia
138 #undef xsi
139 #undef nextbits
140 #undef infer
141 
142 
145  int header)
146 {
147  const uint8_t *start, *end;
148  CodedBitstreamUnitType unit_type;
149  uint32_t start_code = -1;
150  size_t unit_size;
151  int err, i, final = 0;
152 
153  start = avpriv_find_start_code(frag->data, frag->data + frag->data_size,
154  &start_code);
155  if (start_code >> 8 != 0x000001) {
156  // No start code found.
157  return AVERROR_INVALIDDATA;
158  }
159 
160  for (i = 0;; i++) {
161  unit_type = start_code & 0xff;
162 
163  if (start == frag->data + frag->data_size) {
164  // The last four bytes form a start code which constitutes
165  // a unit of its own. In this situation avpriv_find_start_code
166  // won't modify start_code at all so modify start_code so that
167  // the next unit will be treated as the last unit.
168  start_code = 0;
169  }
170 
171  end = avpriv_find_start_code(start--, frag->data + frag->data_size,
172  &start_code);
173 
174  // start points to the byte containing the start_code_identifier
175  // (may be the last byte of fragment->data); end points to the byte
176  // following the byte containing the start code identifier (or to
177  // the end of fragment->data).
178  if (start_code >> 8 == 0x000001) {
179  // Unit runs from start to the beginning of the start code
180  // pointed to by end (including any padding zeroes).
181  unit_size = (end - 4) - start;
182  } else {
183  // We didn't find a start code, so this is the final unit.
184  unit_size = end - start;
185  final = 1;
186  }
187 
188  err = ff_cbs_insert_unit_data(frag, i, unit_type, (uint8_t*)start,
189  unit_size, frag->data_ref);
190  if (err < 0)
191  return err;
192 
193  if (final)
194  break;
195 
196  start = end;
197  }
198 
199  return 0;
200 }
201 
203  CodedBitstreamUnit *unit)
204 {
205  GetBitContext gbc;
206  int err;
207 
208  err = init_get_bits(&gbc, unit->data, 8 * unit->data_size);
209  if (err < 0)
210  return err;
211 
212  err = ff_cbs_alloc_unit_content2(ctx, unit);
213  if (err < 0)
214  return err;
215 
216  if (MPEG2_START_IS_SLICE(unit->type)) {
217  MPEG2RawSlice *slice = unit->content;
218  int pos, len;
219 
220  err = cbs_mpeg2_read_slice_header(ctx, &gbc, &slice->header);
221  if (err < 0)
222  return err;
223 
224  if (!get_bits_left(&gbc))
225  return AVERROR_INVALIDDATA;
226 
227  pos = get_bits_count(&gbc);
228  len = unit->data_size;
229 
230  slice->data_size = len - pos / 8;
231  slice->data_ref = av_buffer_ref(unit->data_ref);
232  if (!slice->data_ref)
233  return AVERROR(ENOMEM);
234  slice->data = unit->data + pos / 8;
235 
236  slice->data_bit_start = pos % 8;
237 
238  } else {
239  switch (unit->type) {
240 #define START(start_code, type, read_func, free_func) \
241  case start_code: \
242  { \
243  type *header = unit->content; \
244  err = cbs_mpeg2_read_ ## read_func(ctx, &gbc, header); \
245  if (err < 0) \
246  return err; \
247  } \
248  break;
250  picture_header, &cbs_mpeg2_free_picture_header);
252  user_data, &cbs_mpeg2_free_user_data);
260  sequence_end, NULL);
261 #undef START
262  default:
263  return AVERROR(ENOSYS);
264  }
265  }
266 
267  return 0;
268 }
269 
271  CodedBitstreamUnit *unit,
272  PutBitContext *pbc)
273 {
274  int err;
275 
276  switch (unit->type) {
277 #define START(start_code, type, func) \
278  case start_code: \
279  err = cbs_mpeg2_write_ ## func(ctx, pbc, unit->content); \
280  break;
288 #undef START
289  default:
290  av_log(ctx->log_ctx, AV_LOG_ERROR, "Write unimplemented for start "
291  "code %02"PRIx32".\n", unit->type);
292  return AVERROR_PATCHWELCOME;
293  }
294 
295  return err;
296 }
297 
299  CodedBitstreamUnit *unit,
300  PutBitContext *pbc)
301 {
302  MPEG2RawSlice *slice = unit->content;
303  int err;
304 
305  err = cbs_mpeg2_write_slice_header(ctx, pbc, &slice->header);
306  if (err < 0)
307  return err;
308 
309  if (slice->data) {
310  size_t rest = slice->data_size - (slice->data_bit_start + 7) / 8;
311  uint8_t *pos = slice->data + slice->data_bit_start / 8;
312 
313  av_assert0(slice->data_bit_start >= 0 &&
314  slice->data_size > slice->data_bit_start / 8);
315 
316  if (slice->data_size * 8 + 8 > put_bits_left(pbc))
317  return AVERROR(ENOSPC);
318 
319  // First copy the remaining bits of the first byte
320  if (slice->data_bit_start % 8)
321  put_bits(pbc, 8 - slice->data_bit_start % 8,
322  *pos++ & MAX_UINT_BITS(8 - slice->data_bit_start % 8));
323 
324  if (put_bits_count(pbc) % 8 == 0) {
325  // If the writer is aligned at this point,
326  // memcpy can be used to improve performance.
327  // This is the normal case.
328  flush_put_bits(pbc);
329  memcpy(put_bits_ptr(pbc), pos, rest);
330  skip_put_bytes(pbc, rest);
331  } else {
332  // If not, we have to copy manually:
333  for (; rest > 3; rest -= 4, pos += 4)
334  put_bits32(pbc, AV_RB32(pos));
335 
336  for (; rest; rest--, pos++)
337  put_bits(pbc, 8, *pos);
338 
339  // Align with zeros
340  put_bits(pbc, 8 - put_bits_count(pbc) % 8, 0);
341  }
342  }
343 
344  return 0;
345 }
346 
348  CodedBitstreamUnit *unit,
349  PutBitContext *pbc)
350 {
351  if (MPEG2_START_IS_SLICE(unit->type))
352  return cbs_mpeg2_write_slice (ctx, unit, pbc);
353  else
354  return cbs_mpeg2_write_header(ctx, unit, pbc);
355 }
356 
359 {
360  uint8_t *data;
361  size_t size, dp;
362  int i;
363 
364  size = 0;
365  for (i = 0; i < frag->nb_units; i++)
366  size += 3 + frag->units[i].data_size;
367 
369  if (!frag->data_ref)
370  return AVERROR(ENOMEM);
371  data = frag->data_ref->data;
372 
373  dp = 0;
374  for (i = 0; i < frag->nb_units; i++) {
375  CodedBitstreamUnit *unit = &frag->units[i];
376 
377  data[dp++] = 0;
378  data[dp++] = 0;
379  data[dp++] = 1;
380 
381  memcpy(data + dp, unit->data, unit->data_size);
382  dp += unit->data_size;
383  }
384 
385  av_assert0(dp == size);
386 
387  memset(data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
388  frag->data = data;
389  frag->data_size = size;
390 
391  return 0;
392 }
393 
396  extra_information_picture.extra_information),
397 
398  {
399  .nb_unit_types = CBS_UNIT_TYPE_RANGE,
400  .unit_type_range_start = 0x01,
401  .unit_type_range_end = 0xaf,
402 
403  .content_type = CBS_CONTENT_TYPE_INTERNAL_REFS,
404  .content_size = sizeof(MPEG2RawSlice),
405  .nb_ref_offsets = 2,
406  .ref_offsets = { offsetof(MPEG2RawSlice, header.extra_information_slice.extra_information),
407  offsetof(MPEG2RawSlice, data) },
408  },
409 
411  user_data),
412 
417 
419 };
420 
423 
424  .priv_data_size = sizeof(CodedBitstreamMPEG2Context),
425 
426  .unit_types = cbs_mpeg2_unit_types,
427 
428  .split_fragment = &cbs_mpeg2_split_fragment,
429  .read_unit = &cbs_mpeg2_read_unit,
430  .write_unit = &cbs_mpeg2_write_unit,
431  .assemble_fragment = &cbs_mpeg2_assemble_fragment,
432 };
int ff_cbs_alloc_unit_content2(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
Allocate a new internal content buffer matching the type of the unit.
Definition: cbs.c:847
static void av_unused put_bits32(PutBitContext *s, uint32_t value)
Write exactly 32 bits into a bitstream.
Definition: put_bits.h:268
#define NULL
Definition: coverity.c:32
int nb_units
Number of units in this fragment.
Definition: cbs.h:149
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static const CodedBitstreamUnitTypeDescriptor cbs_mpeg2_unit_types[]
Definition: cbs_mpeg2.c:394
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
uint8_t * data
Definition: cbs_mpeg2.h:209
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:218
CodedBitstreamUnitType type
Codec-specific type of this unit.
Definition: cbs.h:70
static int cbs_mpeg2_read_unit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
Definition: cbs_mpeg2.c:202
int ff_cbs_insert_unit_data(CodedBitstreamFragment *frag, int position, CodedBitstreamUnitType type, uint8_t *data, size_t data_size, AVBufferRef *data_buf)
Insert a new unit into a fragment with the given data bitstream.
Definition: cbs.c:751
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
static int cbs_mpeg2_assemble_fragment(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Definition: cbs_mpeg2.c:357
uint8_t
uint32_t CodedBitstreamUnitType
The codec-specific type of a bitstream unit.
Definition: cbs.h:43
#define MAX_UINT_BITS(length)
Definition: cbs_internal.h:160
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:92
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_RB32
Definition: bytestream.h:87
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
#define CBS_UNIT_TYPE_INTERNAL_REF(type, structure, ref_field)
Definition: cbs_internal.h:177
Coded bitstream unit structure.
Definition: cbs.h:66
ptrdiff_t size
Definition: opengl_enc.c:100
void * content
Pointer to the decomposed form of this unit.
Definition: cbs.h:103
static const uint8_t header[24]
Definition: sdr2.c:67
CodedBitstreamUnit * units
Pointer to an array of units of length nb_units_allocated.
Definition: cbs.h:164
uint8_t * data
Pointer to the directly-parsable bitstream form of this unit.
Definition: cbs.h:77
#define av_log(a,...)
const uint8_t * avpriv_find_start_code(const uint8_t *p, const uint8_t *end, uint32_t *state)
size_t data_size
The number of bytes in the bitstream.
Definition: cbs.h:131
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
static int FUNC() extension_data(CodedBitstreamContext *ctx, RWContext *rw, H265RawExtensionData *current)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
static uint8_t * put_bits_ptr(PutBitContext *s)
Return the pointer to the byte where the bitstream writer will put the next bit.
Definition: put_bits.h:347
static int put_bits_left(PutBitContext *s)
Definition: put_bits.h:107
unsigned int pos
Definition: spdifenc.c:410
simple assert() macros that are a bit more flexible than ISO C assert().
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:81
static int cbs_mpeg2_split_fragment(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, int header)
Definition: cbs_mpeg2.c:143
static int FUNC() picture_header(CodedBitstreamContext *ctx, RWContext *rw, MPEG2RawPictureHeader *current)
void * log_ctx
Logging context to be passed to all av_log() calls associated with this context.
Definition: cbs.h:175
static void skip_put_bytes(PutBitContext *s, int n)
Skip the given number of bytes.
Definition: put_bits.h:356
#define CBS_UNIT_TYPE_POD(type, structure)
Definition: cbs_internal.h:171
#define START(start_code, type, read_func, free_func)
static int FUNC() user_data(CodedBitstreamContext *ctx, RWContext *rw, MPEG2RawUserData *current)
static int FUNC() sequence_end(CodedBitstreamContext *ctx, RWContext *rw, MPEG2RawSequenceEnd *current)
AVFormatContext * ctx
Definition: movenc.c:48
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:51
uint8_t * data
Pointer to the bitstream form of this fragment.
Definition: cbs.h:124
#define CBS_UNIT_TYPE_END_OF_LIST
Definition: cbs_internal.h:192
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
const CodedBitstreamType ff_cbs_type_mpeg2
Definition: cbs_mpeg2.c:421
int data_bit_start
Definition: cbs_mpeg2.h:212
static int FUNC() sequence_header(CodedBitstreamContext *ctx, RWContext *rw, MPEG2RawSequenceHeader *current)
AVBufferRef * av_buffer_alloc(int size)
Allocate an AVBuffer of the given size using av_malloc().
Definition: buffer.c:67
static int cbs_mpeg2_write_unit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, PutBitContext *pbc)
Definition: cbs_mpeg2.c:347
Coded bitstream fragment structure, combining one or more units.
Definition: cbs.h:118
#define MPEG2_START_IS_SLICE(type)
Definition: cbs_mpeg2.h:40
uint8_t * data
The data buffer.
Definition: buffer.h:89
Context structure for coded bitstream operations.
Definition: cbs.h:170
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
enum AVCodecID codec_id
Definition: cbs_internal.h:87
static int cbs_mpeg2_write_slice(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, PutBitContext *pbc)
Definition: cbs_mpeg2.c:298
MPEG2RawSliceHeader header
Definition: cbs_mpeg2.h:207
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:115
AVBufferRef * data_ref
A reference to the buffer containing data.
Definition: cbs.h:94
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
static int FUNC() group_of_pictures_header(CodedBitstreamContext *ctx, RWContext *rw, MPEG2RawGroupOfPicturesHeader *current)
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:215
int len
AVBufferRef * data_ref
Definition: cbs_mpeg2.h:210
size_t data_size
Definition: cbs_mpeg2.h:211
static const uint8_t start_code[]
static int cbs_mpeg2_write_header(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, PutBitContext *pbc)
Definition: cbs_mpeg2.c:270
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
AVBufferRef * data_ref
A reference to the buffer containing data.
Definition: cbs.h:141
int i
Definition: input.c:407
size_t data_size
The number of bytes in the bitstream (including any padding bits in the final byte).
Definition: cbs.h:82