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)
45 #define uis(width, name, subs, ...) \
46  xui(width, name, current->name, subs, __VA_ARGS__)
47 
48 
49 #define READ
50 #define READWRITE read
51 #define RWContext GetBitContext
52 
53 #define xui(width, name, var, subs, ...) do { \
54  uint32_t value = 0; \
55  CHECK(ff_cbs_read_unsigned(ctx, rw, width, #name, \
56  SUBSCRIPTS(subs, __VA_ARGS__), \
57  &value, 0, (1 << width) - 1)); \
58  var = value; \
59  } while (0)
60 
61 #define marker_bit() do { \
62  av_unused uint32_t one; \
63  CHECK(ff_cbs_read_unsigned(ctx, rw, 1, "marker_bit", NULL, &one, 1, 1)); \
64  } while (0)
65 
66 #define nextbits(width, compare, var) \
67  (get_bits_left(rw) >= width && \
68  (var = show_bits(rw, width)) == (compare))
69 
71 
72 #undef READ
73 #undef READWRITE
74 #undef RWContext
75 #undef xui
76 #undef marker_bit
77 #undef nextbits
78 
79 
80 #define WRITE
81 #define READWRITE write
82 #define RWContext PutBitContext
83 
84 #define xui(width, name, var, subs, ...) do { \
85  CHECK(ff_cbs_write_unsigned(ctx, rw, width, #name, \
86  SUBSCRIPTS(subs, __VA_ARGS__), \
87  var, 0, (1 << width) - 1)); \
88  } while (0)
89 
90 #define marker_bit() do { \
91  CHECK(ff_cbs_write_unsigned(ctx, rw, 1, "marker_bit", NULL, 1, 1, 1)); \
92  } while (0)
93 
94 #define nextbits(width, compare, var) (var)
95 
97 
98 #undef READ
99 #undef READWRITE
100 #undef RWContext
101 #undef xui
102 #undef marker_bit
103 #undef nextbits
104 
105 
106 static void cbs_mpeg2_free_user_data(void *unit, uint8_t *content)
107 {
108  MPEG2RawUserData *user = (MPEG2RawUserData*)content;
110  av_freep(&content);
111 }
112 
113 static void cbs_mpeg2_free_slice(void *unit, uint8_t *content)
114 {
115  MPEG2RawSlice *slice = (MPEG2RawSlice*)content;
117  av_buffer_unref(&slice->data_ref);
118  av_freep(&content);
119 }
120 
123  int header)
124 {
125  const uint8_t *start, *end;
126  uint8_t *unit_data;
127  uint32_t start_code = -1, next_start_code = -1;
128  size_t unit_size;
129  int err, i, unit_type;
130 
131  start = avpriv_find_start_code(frag->data, frag->data + frag->data_size,
132  &start_code);
133  for (i = 0;; i++) {
134  end = avpriv_find_start_code(start, frag->data + frag->data_size,
135  &next_start_code);
136 
137  unit_type = start_code & 0xff;
138 
139  // The start and end pointers point at to the byte following the
140  // start_code_identifier in the start code that they found.
141  if (end == frag->data + frag->data_size) {
142  // We didn't find a start code, so this is the final unit.
143  unit_size = end - (start - 1);
144  } else {
145  // Unit runs from start to the beginning of the start code
146  // pointed to by end (including any padding zeroes).
147  unit_size = (end - 4) - (start - 1);
148  }
149 
150  unit_data = (uint8_t *)start - 1;
151 
152  err = ff_cbs_insert_unit_data(ctx, frag, i, unit_type,
153  unit_data, unit_size, frag->data_ref);
154  if (err < 0)
155  return err;
156 
157  if (end == frag->data + frag->data_size)
158  break;
159 
160  start_code = next_start_code;
161  start = end;
162  }
163 
164  return 0;
165 }
166 
168  CodedBitstreamUnit *unit)
169 {
170  GetBitContext gbc;
171  int err;
172 
173  err = init_get_bits(&gbc, unit->data, 8 * unit->data_size);
174  if (err < 0)
175  return err;
176 
177  if (MPEG2_START_IS_SLICE(unit->type)) {
178  MPEG2RawSlice *slice;
179  int pos, len;
180 
181  err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*slice),
183  if (err < 0)
184  return err;
185  slice = unit->content;
186 
187  err = cbs_mpeg2_read_slice_header(ctx, &gbc, &slice->header);
188  if (err < 0)
189  return err;
190 
191  pos = get_bits_count(&gbc);
192  len = unit->data_size;
193 
194  slice->data_size = len - pos / 8;
195  slice->data_ref = av_buffer_ref(unit->data_ref);
196  if (!slice->data_ref)
197  return AVERROR(ENOMEM);
198  slice->data = unit->data + pos / 8;
199 
200  slice->data_bit_start = pos % 8;
201 
202  } else {
203  switch (unit->type) {
204 #define START(start_code, type, read_func, free_func) \
205  case start_code: \
206  { \
207  type *header; \
208  err = ff_cbs_alloc_unit_content(ctx, unit, \
209  sizeof(*header), free_func); \
210  if (err < 0) \
211  return err; \
212  header = unit->content; \
213  err = cbs_mpeg2_read_ ## read_func(ctx, &gbc, header); \
214  if (err < 0) \
215  return err; \
216  } \
217  break;
225 #undef START
226  default:
227  av_log(ctx->log_ctx, AV_LOG_ERROR, "Unknown start code %02"PRIx32".\n",
228  unit->type);
229  return AVERROR_INVALIDDATA;
230  }
231  }
232 
233  return 0;
234 }
235 
237  CodedBitstreamUnit *unit,
238  PutBitContext *pbc)
239 {
240  int err;
241 
242  switch (unit->type) {
243 #define START(start_code, type, func) \
244  case start_code: \
245  err = cbs_mpeg2_write_ ## func(ctx, pbc, unit->content); \
246  break;
252 #undef START
253  default:
254  av_log(ctx->log_ctx, AV_LOG_ERROR, "Write unimplemented for start "
255  "code %02"PRIx32".\n", unit->type);
256  return AVERROR_PATCHWELCOME;
257  }
258 
259  return err;
260 }
261 
263  CodedBitstreamUnit *unit,
264  PutBitContext *pbc)
265 {
266  MPEG2RawSlice *slice = unit->content;
267  int err;
268 
269  err = cbs_mpeg2_write_slice_header(ctx, pbc, &slice->header);
270  if (err < 0)
271  return err;
272 
273  if (slice->data) {
274  size_t rest = slice->data_size - (slice->data_bit_start + 7) / 8;
275  uint8_t *pos = slice->data + slice->data_bit_start / 8;
276 
277  av_assert0(slice->data_bit_start >= 0 &&
278  8 * slice->data_size > slice->data_bit_start);
279 
280  if (slice->data_size * 8 + 8 > put_bits_left(pbc))
281  return AVERROR(ENOSPC);
282 
283  // First copy the remaining bits of the first byte
284  if (slice->data_bit_start % 8)
285  put_bits(pbc, 8 - slice->data_bit_start % 8,
286  *pos++ & MAX_UINT_BITS(8 - slice->data_bit_start % 8));
287 
288  if (put_bits_count(pbc) % 8 == 0) {
289  // If the writer is aligned at this point,
290  // memcpy can be used to improve performance.
291  // This is the normal case.
292  flush_put_bits(pbc);
293  memcpy(put_bits_ptr(pbc), pos, rest);
294  skip_put_bytes(pbc, rest);
295  } else {
296  // If not, we have to copy manually:
297  for (; rest > 3; rest -= 4, pos += 4)
298  put_bits32(pbc, AV_RB32(pos));
299 
300  for (; rest; rest--, pos++)
301  put_bits(pbc, 8, *pos);
302 
303  // Align with zeros
304  put_bits(pbc, 8 - put_bits_count(pbc) % 8, 0);
305  }
306  }
307 
308  return 0;
309 }
310 
312  CodedBitstreamUnit *unit)
313 {
315  PutBitContext pbc;
316  int err;
317 
318  if (!priv->write_buffer) {
319  // Initial write buffer size is 1MB.
320  priv->write_buffer_size = 1024 * 1024;
321 
322  reallocate_and_try_again:
323  err = av_reallocp(&priv->write_buffer, priv->write_buffer_size);
324  if (err < 0) {
325  av_log(ctx->log_ctx, AV_LOG_ERROR, "Unable to allocate a "
326  "sufficiently large write buffer (last attempt "
327  "%"SIZE_SPECIFIER" bytes).\n", priv->write_buffer_size);
328  return err;
329  }
330  }
331 
332  init_put_bits(&pbc, priv->write_buffer, priv->write_buffer_size);
333 
334  if (unit->type >= 0x01 && unit->type <= 0xaf)
335  err = cbs_mpeg2_write_slice(ctx, unit, &pbc);
336  else
337  err = cbs_mpeg2_write_header(ctx, unit, &pbc);
338 
339  if (err == AVERROR(ENOSPC)) {
340  // Overflow.
341  priv->write_buffer_size *= 2;
342  goto reallocate_and_try_again;
343  }
344  if (err < 0) {
345  // Write failed for some other reason.
346  return err;
347  }
348 
349  if (put_bits_count(&pbc) % 8)
350  unit->data_bit_padding = 8 - put_bits_count(&pbc) % 8;
351  else
352  unit->data_bit_padding = 0;
353 
354  unit->data_size = (put_bits_count(&pbc) + 7) / 8;
355  flush_put_bits(&pbc);
356 
357  err = ff_cbs_alloc_unit_data(ctx, unit, unit->data_size);
358  if (err < 0)
359  return err;
360 
361  memcpy(unit->data, priv->write_buffer, unit->data_size);
362 
363  return 0;
364 }
365 
368 {
369  uint8_t *data;
370  size_t size, dp;
371  int i;
372 
373  size = 0;
374  for (i = 0; i < frag->nb_units; i++)
375  size += 3 + frag->units[i].data_size;
376 
378  if (!frag->data_ref)
379  return AVERROR(ENOMEM);
380  data = frag->data_ref->data;
381 
382  dp = 0;
383  for (i = 0; i < frag->nb_units; i++) {
384  CodedBitstreamUnit *unit = &frag->units[i];
385 
386  data[dp++] = 0;
387  data[dp++] = 0;
388  data[dp++] = 1;
389 
390  memcpy(data + dp, unit->data, unit->data_size);
391  dp += unit->data_size;
392  }
393 
394  av_assert0(dp == size);
395 
396  memset(data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
397  frag->data = data;
398  frag->data_size = size;
399 
400  return 0;
401 }
402 
404 {
406 
407  av_freep(&priv->write_buffer);
408 }
409 
412 
413  .priv_data_size = sizeof(CodedBitstreamMPEG2Context),
414 
415  .split_fragment = &cbs_mpeg2_split_fragment,
416  .read_unit = &cbs_mpeg2_read_unit,
417  .write_unit = &cbs_mpeg2_write_unit,
418  .assemble_fragment = &cbs_mpeg2_assemble_fragment,
419 
420  .close = &cbs_mpeg2_close,
421 };
static void av_unused put_bits32(PutBitContext *s, uint32_t value)
Write exactly 32 bits into a bitstream.
Definition: put_bits.h:250
#define NULL
Definition: coverity.c:32
int nb_units
Number of units in this fragment.
Definition: cbs.h:147
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
Definition: buffer.c:125
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
uint8_t * data
Definition: cbs_mpeg2.h:207
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:208
CodedBitstreamUnitType type
Codec-specific type of this unit.
Definition: cbs.h:68
int ff_cbs_alloc_unit_content(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, size_t size, void(*free)(void *opaque, uint8_t *data))
Definition: cbs.c:508
static int cbs_mpeg2_write_unit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
Definition: cbs_mpeg2.c:311
static void cbs_mpeg2_free_user_data(void *unit, uint8_t *content)
Definition: cbs_mpeg2.c:106
static int cbs_mpeg2_read_unit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
Definition: cbs_mpeg2.c:167
#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:366
static int FUNC() extension_data(CodedBitstreamContext *ctx, RWContext *rw, H265RawPSExtensionData *current)
uint8_t
#define MAX_UINT_BITS(length)
Definition: cbs_internal.h:86
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
AVBufferRef * extra_information_ref
Definition: cbs_mpeg2.h:201
size_t data_bit_padding
The number of bits which should be ignored in the final byte.
Definition: cbs.h:86
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
int ff_cbs_alloc_unit_data(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, size_t size)
Allocate a new internal data buffer of the given size in the unit.
Definition: cbs.c:529
Coded bitstream unit structure.
Definition: cbs.h:64
ptrdiff_t size
Definition: opengl_enc.c:101
void * content
Pointer to the decomposed form of this unit.
Definition: cbs.h:101
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:162
uint8_t * data
Pointer to the directly-parsable bitstream form of this unit.
Definition: cbs.h:75
int ff_cbs_insert_unit_data(CodedBitstreamContext *ctx, 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:623
#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:129
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
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:324
static int put_bits_left(PutBitContext *s)
Definition: put_bits.h:93
AVS_Value void * user_data
Definition: avisynth_c.h:699
AVBufferRef * user_data_ref
Definition: cbs_mpeg2.h:81
simple assert() macros that are a bit more flexible than ISO C assert().
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:85
static int cbs_mpeg2_split_fragment(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, int header)
Definition: cbs_mpeg2.c:121
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:173
static void skip_put_bytes(PutBitContext *s, int n)
Skip the given number of bytes.
Definition: put_bits.h:333
#define START(start_code, type, read_func, free_func)
AVFormatContext * ctx
Definition: movenc.c:48
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:220
uint8_t * data
Pointer to the bitstream form of this fragment.
Definition: cbs.h:122
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
const CodedBitstreamType ff_cbs_type_mpeg2
Definition: cbs_mpeg2.c:410
int av_reallocp(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory through a pointer to a pointer.
Definition: mem.c:163
int data_bit_start
Definition: cbs_mpeg2.h:209
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
Coded bitstream fragment structure, combining one or more units.
Definition: cbs.h:116
#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:168
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:616
enum AVCodecID codec_id
Definition: cbs_internal.h:29
#define SIZE_SPECIFIER
Definition: internal.h:262
static int cbs_mpeg2_write_slice(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, PutBitContext *pbc)
Definition: cbs_mpeg2.c:262
MPEG2RawSliceHeader header
Definition: cbs_mpeg2.h:205
void * priv_data
Internal codec-specific data.
Definition: cbs.h:189
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:101
static void cbs_mpeg2_close(CodedBitstreamContext *ctx)
Definition: cbs_mpeg2.c:403
AVBufferRef * data_ref
A reference to the buffer containing data.
Definition: cbs.h:92
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)
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:48
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:786
int len
static void cbs_mpeg2_free_slice(void *unit, uint8_t *content)
Definition: cbs_mpeg2.c:113
AVBufferRef * data_ref
Definition: cbs_mpeg2.h:210
size_t data_size
Definition: cbs_mpeg2.h:208
#define av_freep(p)
void INT64 start
Definition: avisynth_c.h:690
static const uint8_t start_code[]
static int cbs_mpeg2_write_header(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, PutBitContext *pbc)
Definition: cbs_mpeg2.c:236
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:139
size_t data_size
The number of bytes in the bitstream (including any padding bits in the final byte).
Definition: cbs.h:80