FFmpeg
avc.c
Go to the documentation of this file.
1 /*
2  * AVC helper functions for muxers
3  * Copyright (c) 2006 Baptiste Coudurier <baptiste.coudurier@smartjog.com>
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 #include "libavutil/intreadwrite.h"
23 #include "libavcodec/h264.h"
24 #include "libavcodec/get_bits.h"
25 #include "avformat.h"
26 #include "avio.h"
27 #include "avc.h"
28 #include "avio_internal.h"
29 
30 static const uint8_t *ff_avc_find_startcode_internal(const uint8_t *p, const uint8_t *end)
31 {
32  const uint8_t *a = p + 4 - ((intptr_t)p & 3);
33 
34  for (end -= 3; p < a && p < end; p++) {
35  if (p[0] == 0 && p[1] == 0 && p[2] == 1)
36  return p;
37  }
38 
39  for (end -= 3; p < end; p += 4) {
40  uint32_t x = *(const uint32_t*)p;
41 // if ((x - 0x01000100) & (~x) & 0x80008000) // little endian
42 // if ((x - 0x00010001) & (~x) & 0x00800080) // big endian
43  if ((x - 0x01010101) & (~x) & 0x80808080) { // generic
44  if (p[1] == 0) {
45  if (p[0] == 0 && p[2] == 1)
46  return p;
47  if (p[2] == 0 && p[3] == 1)
48  return p+1;
49  }
50  if (p[3] == 0) {
51  if (p[2] == 0 && p[4] == 1)
52  return p+2;
53  if (p[4] == 0 && p[5] == 1)
54  return p+3;
55  }
56  }
57  }
58 
59  for (end += 3; p < end; p++) {
60  if (p[0] == 0 && p[1] == 0 && p[2] == 1)
61  return p;
62  }
63 
64  return end + 3;
65 }
66 
67 const uint8_t *ff_avc_find_startcode(const uint8_t *p, const uint8_t *end){
69  if(p<out && out<end && !out[-1]) out--;
70  return out;
71 }
72 
73 int ff_avc_parse_nal_units(AVIOContext *pb, const uint8_t *buf_in, int size)
74 {
75  const uint8_t *p = buf_in;
76  const uint8_t *end = p + size;
77  const uint8_t *nal_start, *nal_end;
78 
79  size = 0;
80  nal_start = ff_avc_find_startcode(p, end);
81  for (;;) {
82  while (nal_start < end && !*(nal_start++));
83  if (nal_start == end)
84  break;
85 
86  nal_end = ff_avc_find_startcode(nal_start, end);
87  avio_wb32(pb, nal_end - nal_start);
88  avio_write(pb, nal_start, nal_end - nal_start);
89  size += 4 + nal_end - nal_start;
90  nal_start = nal_end;
91  }
92  return size;
93 }
94 
95 int ff_avc_parse_nal_units_buf(const uint8_t *buf_in, uint8_t **buf, int *size)
96 {
97  AVIOContext *pb;
98  int ret = avio_open_dyn_buf(&pb);
99  if(ret < 0)
100  return ret;
101 
102  ff_avc_parse_nal_units(pb, buf_in, *size);
103 
104  av_freep(buf);
105  *size = avio_close_dyn_buf(pb, buf);
106  return 0;
107 }
108 
110 {
111  AVIOContext *sps_pb = NULL, *pps_pb = NULL, *sps_ext_pb = NULL;
112  uint8_t *buf = NULL, *end, *start = NULL;
113  uint8_t *sps, *pps, *sps_ext;
114  uint32_t sps_size = 0, pps_size = 0, sps_ext_size = 0;
115  int ret, nb_sps = 0, nb_pps = 0, nb_sps_ext = 0;
116 
117  if (len <= 6)
118  return AVERROR_INVALIDDATA;
119 
120  /* check for H.264 start code */
121  if (AV_RB32(data) != 0x00000001 &&
122  AV_RB24(data) != 0x000001) {
123  avio_write(pb, data, len);
124  return 0;
125  }
126 
127  ret = ff_avc_parse_nal_units_buf(data, &buf, &len);
128  if (ret < 0)
129  return ret;
130  start = buf;
131  end = buf + len;
132 
133  ret = avio_open_dyn_buf(&sps_pb);
134  if (ret < 0)
135  goto fail;
136  ret = avio_open_dyn_buf(&pps_pb);
137  if (ret < 0)
138  goto fail;
139  ret = avio_open_dyn_buf(&sps_ext_pb);
140  if (ret < 0)
141  goto fail;
142 
143  /* look for sps and pps */
144  while (end - buf > 4) {
145  uint32_t size;
146  uint8_t nal_type;
147  size = FFMIN(AV_RB32(buf), end - buf - 4);
148  buf += 4;
149  nal_type = buf[0] & 0x1f;
150 
151  if (nal_type == 7) { /* SPS */
152  nb_sps++;
153  if (size > UINT16_MAX || nb_sps >= H264_MAX_SPS_COUNT) {
154  ret = AVERROR_INVALIDDATA;
155  goto fail;
156  }
157  avio_wb16(sps_pb, size);
158  avio_write(sps_pb, buf, size);
159  } else if (nal_type == 8) { /* PPS */
160  nb_pps++;
161  if (size > UINT16_MAX || nb_pps >= H264_MAX_PPS_COUNT) {
162  ret = AVERROR_INVALIDDATA;
163  goto fail;
164  }
165  avio_wb16(pps_pb, size);
166  avio_write(pps_pb, buf, size);
167  } else if (nal_type == 13) { /* SPS_EXT */
168  nb_sps_ext++;
169  if (size > UINT16_MAX || nb_sps_ext >= 256) {
170  ret = AVERROR_INVALIDDATA;
171  goto fail;
172  }
173  avio_wb16(sps_ext_pb, size);
174  avio_write(sps_ext_pb, buf, size);
175  }
176 
177  buf += size;
178  }
179  sps_size = avio_get_dyn_buf(sps_pb, &sps);
180  pps_size = avio_get_dyn_buf(pps_pb, &pps);
181  sps_ext_size = avio_get_dyn_buf(sps_ext_pb, &sps_ext);
182 
183  if (sps_size < 6 || !pps_size) {
184  ret = AVERROR_INVALIDDATA;
185  goto fail;
186  }
187 
188  avio_w8(pb, 1); /* version */
189  avio_w8(pb, sps[3]); /* profile */
190  avio_w8(pb, sps[4]); /* profile compat */
191  avio_w8(pb, sps[5]); /* level */
192  avio_w8(pb, 0xff); /* 6 bits reserved (111111) + 2 bits nal size length - 1 (11) */
193  avio_w8(pb, 0xe0 | nb_sps); /* 3 bits reserved (111) + 5 bits number of sps */
194 
195  avio_write(pb, sps, sps_size);
196  avio_w8(pb, nb_pps); /* number of pps */
197  avio_write(pb, pps, pps_size);
198 
199  if (sps[3] != 66 && sps[3] != 77 && sps[3] != 88) {
200  H264SequenceParameterSet *seq = ff_avc_decode_sps(sps + 3, sps_size - 3);
201  if (!seq) {
202  ret = AVERROR(ENOMEM);
203  goto fail;
204  }
205  avio_w8(pb, 0xfc | seq->chroma_format_idc); /* 6 bits reserved (111111) + chroma_format_idc */
206  avio_w8(pb, 0xf8 | (seq->bit_depth_luma - 8)); /* 5 bits reserved (11111) + bit_depth_luma_minus8 */
207  avio_w8(pb, 0xf8 | (seq->bit_depth_chroma - 8)); /* 5 bits reserved (11111) + bit_depth_chroma_minus8 */
208  avio_w8(pb, nb_sps_ext); /* number of sps ext */
209  if (nb_sps_ext)
210  avio_write(pb, sps_ext, sps_ext_size);
211  av_free(seq);
212  }
213 
214 fail:
215  ffio_free_dyn_buf(&sps_pb);
216  ffio_free_dyn_buf(&pps_pb);
217  ffio_free_dyn_buf(&sps_ext_pb);
218  av_free(start);
219 
220  return ret;
221 }
222 
224 {
225  uint16_t sps_size, pps_size;
226  uint8_t *out;
227  int out_size;
228 
229  *buf = NULL;
230  if (*size >= 4 && (AV_RB32(in) == 0x00000001 || AV_RB24(in) == 0x000001))
231  return 0;
232  if (*size < 11 || in[0] != 1)
233  return AVERROR_INVALIDDATA;
234 
235  sps_size = AV_RB16(&in[6]);
236  if (11 + sps_size > *size)
237  return AVERROR_INVALIDDATA;
238  pps_size = AV_RB16(&in[9 + sps_size]);
239  if (11 + sps_size + pps_size > *size)
240  return AVERROR_INVALIDDATA;
241  out_size = 8 + sps_size + pps_size;
242  out = av_mallocz(out_size + AV_INPUT_BUFFER_PADDING_SIZE);
243  if (!out)
244  return AVERROR(ENOMEM);
245  AV_WB32(&out[0], 0x00000001);
246  memcpy(out + 4, &in[8], sps_size);
247  AV_WB32(&out[4 + sps_size], 0x00000001);
248  memcpy(out + 8 + sps_size, &in[11 + sps_size], pps_size);
249  *buf = out;
250  *size = out_size;
251  return 0;
252 }
253 
255  const uint8_t *end,
256  int nal_length_size)
257 {
258  unsigned int res = 0;
259 
260  if (end - start < nal_length_size)
261  return NULL;
262  while (nal_length_size--)
263  res = (res << 8) | *start++;
264 
265  if (res > end - start)
266  return NULL;
267 
268  return start + res;
269 }
270 
271 uint8_t *ff_nal_unit_extract_rbsp(const uint8_t *src, uint32_t src_len,
272  uint32_t *dst_len, int header_len)
273 {
274  uint8_t *dst;
275  uint32_t i, len;
276 
277  dst = av_malloc(src_len + AV_INPUT_BUFFER_PADDING_SIZE);
278  if (!dst)
279  return NULL;
280 
281  /* NAL unit header */
282  i = len = 0;
283  while (i < header_len && i < src_len)
284  dst[len++] = src[i++];
285 
286  while (i + 2 < src_len)
287  if (!src[i] && !src[i + 1] && src[i + 2] == 3) {
288  dst[len++] = src[i++];
289  dst[len++] = src[i++];
290  i++; // remove emulation_prevention_three_byte
291  } else
292  dst[len++] = src[i++];
293 
294  while (i < src_len)
295  dst[len++] = src[i++];
296 
297  memset(dst + len, 0, AV_INPUT_BUFFER_PADDING_SIZE);
298 
299  *dst_len = len;
300  return dst;
301 }
302 
304  { 0, 1 },
305  { 1, 1 },
306  { 12, 11 },
307  { 10, 11 },
308  { 16, 11 },
309  { 40, 33 },
310  { 24, 11 },
311  { 20, 11 },
312  { 32, 11 },
313  { 80, 33 },
314  { 18, 11 },
315  { 15, 11 },
316  { 64, 33 },
317  { 160, 99 },
318  { 4, 3 },
319  { 3, 2 },
320  { 2, 1 },
321 };
322 
323 static inline int get_ue_golomb(GetBitContext *gb) {
324  int i;
325  for (i = 0; i < 32 && !get_bits1(gb); i++)
326  ;
327  return get_bitsz(gb, i) + (1 << i) - 1;
328 }
329 
330 static inline int get_se_golomb(GetBitContext *gb) {
331  int v = get_ue_golomb(gb) + 1;
332  int sign = -(v & 1);
333  return ((v >> 1) ^ sign) - sign;
334 }
335 
337 {
338  int i, j, ret, rbsp_size, aspect_ratio_idc, pic_order_cnt_type;
339  int num_ref_frames_in_pic_order_cnt_cycle;
340  int delta_scale, lastScale = 8, nextScale = 8;
341  int sizeOfScalingList;
343  GetBitContext gb;
344  uint8_t *rbsp_buf;
345 
346  rbsp_buf = ff_nal_unit_extract_rbsp(buf, buf_size, &rbsp_size, 0);
347  if (!rbsp_buf)
348  return NULL;
349 
350  ret = init_get_bits8(&gb, rbsp_buf, rbsp_size);
351  if (ret < 0)
352  goto end;
353 
354  sps = av_mallocz(sizeof(*sps));
355  if (!sps)
356  goto end;
357 
358  sps->profile_idc = get_bits(&gb, 8);
359  sps->constraint_set_flags |= get_bits1(&gb) << 0; // constraint_set0_flag
360  sps->constraint_set_flags |= get_bits1(&gb) << 1; // constraint_set1_flag
361  sps->constraint_set_flags |= get_bits1(&gb) << 2; // constraint_set2_flag
362  sps->constraint_set_flags |= get_bits1(&gb) << 3; // constraint_set3_flag
363  sps->constraint_set_flags |= get_bits1(&gb) << 4; // constraint_set4_flag
364  sps->constraint_set_flags |= get_bits1(&gb) << 5; // constraint_set5_flag
365  skip_bits(&gb, 2); // reserved_zero_2bits
366  sps->level_idc = get_bits(&gb, 8);
367  sps->id = get_ue_golomb(&gb);
368 
369  if (sps->profile_idc == 100 || sps->profile_idc == 110 ||
370  sps->profile_idc == 122 || sps->profile_idc == 244 || sps->profile_idc == 44 ||
371  sps->profile_idc == 83 || sps->profile_idc == 86 || sps->profile_idc == 118 ||
372  sps->profile_idc == 128 || sps->profile_idc == 138 || sps->profile_idc == 139 ||
373  sps->profile_idc == 134) {
374  sps->chroma_format_idc = get_ue_golomb(&gb); // chroma_format_idc
375  if (sps->chroma_format_idc == 3) {
376  skip_bits1(&gb); // separate_colour_plane_flag
377  }
378  sps->bit_depth_luma = get_ue_golomb(&gb) + 8;
379  sps->bit_depth_chroma = get_ue_golomb(&gb) + 8;
380  skip_bits1(&gb); // qpprime_y_zero_transform_bypass_flag
381  if (get_bits1(&gb)) { // seq_scaling_matrix_present_flag
382  for (i = 0; i < ((sps->chroma_format_idc != 3) ? 8 : 12); i++) {
383  if (!get_bits1(&gb)) // seq_scaling_list_present_flag
384  continue;
385  lastScale = 8;
386  nextScale = 8;
387  sizeOfScalingList = i < 6 ? 16 : 64;
388  for (j = 0; j < sizeOfScalingList; j++) {
389  if (nextScale != 0) {
390  delta_scale = get_se_golomb(&gb);
391  nextScale = (lastScale + delta_scale) & 0xff;
392  }
393  lastScale = nextScale == 0 ? lastScale : nextScale;
394  }
395  }
396  }
397  } else {
398  sps->chroma_format_idc = 1;
399  sps->bit_depth_luma = 8;
400  sps->bit_depth_chroma = 8;
401  }
402 
403  get_ue_golomb(&gb); // log2_max_frame_num_minus4
404  pic_order_cnt_type = get_ue_golomb(&gb);
405 
406  if (pic_order_cnt_type == 0) {
407  get_ue_golomb(&gb); // log2_max_pic_order_cnt_lsb_minus4
408  } else if (pic_order_cnt_type == 1) {
409  skip_bits1(&gb); // delta_pic_order_always_zero
410  get_se_golomb(&gb); // offset_for_non_ref_pic
411  get_se_golomb(&gb); // offset_for_top_to_bottom_field
412  num_ref_frames_in_pic_order_cnt_cycle = get_ue_golomb(&gb);
413  for (i = 0; i < num_ref_frames_in_pic_order_cnt_cycle; i++)
414  get_se_golomb(&gb); // offset_for_ref_frame
415  }
416 
417  get_ue_golomb(&gb); // max_num_ref_frames
418  skip_bits1(&gb); // gaps_in_frame_num_value_allowed_flag
419  get_ue_golomb(&gb); // pic_width_in_mbs_minus1
420  get_ue_golomb(&gb); // pic_height_in_map_units_minus1
421 
422  sps->frame_mbs_only_flag = get_bits1(&gb);
423  if (!sps->frame_mbs_only_flag)
424  skip_bits1(&gb); // mb_adaptive_frame_field_flag
425 
426  skip_bits1(&gb); // direct_8x8_inference_flag
427 
428  if (get_bits1(&gb)) { // frame_cropping_flag
429  get_ue_golomb(&gb); // frame_crop_left_offset
430  get_ue_golomb(&gb); // frame_crop_right_offset
431  get_ue_golomb(&gb); // frame_crop_top_offset
432  get_ue_golomb(&gb); // frame_crop_bottom_offset
433  }
434 
435  if (get_bits1(&gb)) { // vui_parameters_present_flag
436  if (get_bits1(&gb)) { // aspect_ratio_info_present_flag
437  aspect_ratio_idc = get_bits(&gb, 8);
438  if (aspect_ratio_idc == 0xff) {
439  sps->sar.num = get_bits(&gb, 16);
440  sps->sar.den = get_bits(&gb, 16);
441  } else if (aspect_ratio_idc < FF_ARRAY_ELEMS(avc_sample_aspect_ratio)) {
442  sps->sar = avc_sample_aspect_ratio[aspect_ratio_idc];
443  }
444  }
445  }
446 
447  if (!sps->sar.den) {
448  sps->sar.num = 1;
449  sps->sar.den = 1;
450  }
451 
452  end:
453  av_free(rbsp_buf);
454  return sps;
455 }
uint8_t chroma_format_idc
Definition: avc.h:44
#define NULL
Definition: coverity.c:32
Bytestream IO Context.
Definition: avio.h:161
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static int get_se_golomb(GetBitContext *gb)
Definition: avc.c:330
Buffered I/O operations.
const uint8_t * ff_avc_find_startcode(const uint8_t *p, const uint8_t *end)
Definition: avc.c:67
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1464
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
static int get_ue_golomb(GetBitContext *gb)
Definition: avc.c:323
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
int num
Numerator.
Definition: rational.h:59
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
int out_size
Definition: movenc.c:55
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
uint8_t level_idc
Definition: avc.h:42
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:87
#define src
Definition: vp8dsp.c:254
int avio_open_dyn_buf(AVIOContext **s)
Open a write only memory stream.
Definition: aviobuf.c:1430
uint8_t bit_depth_luma
Definition: avc.h:45
static const AVRational avc_sample_aspect_ratio[17]
Definition: avc.c:303
uint8_t
#define av_malloc(s)
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
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
int ff_avc_write_annexb_extradata(const uint8_t *in, uint8_t **buf, int *size)
Definition: avc.c:223
bitstream reader API header.
ptrdiff_t size
Definition: opengl_enc.c:100
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:218
H.264 common definitions.
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
int ff_avc_parse_nal_units_buf(const uint8_t *buf_in, uint8_t **buf, int *size)
Definition: avc.c:95
#define fail()
Definition: checkasm.h:122
int ff_avc_parse_nal_units(AVIOContext *pb, const uint8_t *buf_in, int size)
Definition: avc.c:73
#define FFMIN(a, b)
Definition: common.h:96
uint8_t frame_mbs_only_flag
Definition: avc.h:47
static const uint8_t * ff_avc_find_startcode_internal(const uint8_t *p, const uint8_t *end)
Definition: avc.c:30
uint8_t bit_depth_chroma
Definition: avc.h:46
uint8_t constraint_set_flags
Definition: avc.h:43
uint8_t * ff_nal_unit_extract_rbsp(const uint8_t *src, uint32_t src_len, uint32_t *dst_len, int header_len)
Definition: avc.c:271
#define FF_ARRAY_ELEMS(a)
void ffio_free_dyn_buf(AVIOContext **s)
Free a dynamic buffer.
Definition: aviobuf.c:1494
AVRational sar
Definition: avc.h:48
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_RB24
Definition: bytestream.h:87
uint8_t profile_idc
Definition: avc.h:41
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:196
void * buf
Definition: avisynth_c.h:766
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31))))#define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac){}void ff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map){AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);return NULL;}return ac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;}int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){int use_generic=1;int len=in->nb_samples;int p;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%d samples - audio_convert: %s to %s (dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:538
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H264RawPPS *current)
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
Rational number (pair of numerator and denominator).
Definition: rational.h:58
const uint8_t * ff_avc_mp4_find_startcode(const uint8_t *start, const uint8_t *end, int nal_length_size)
Definition: avc.c:254
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
void avio_wb16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:478
Main libavformat public API header.
H264SequenceParameterSet * ff_avc_decode_sps(const uint8_t *buf, int buf_size)
Definition: avc.c:336
int den
Denominator.
Definition: rational.h:60
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:795
#define av_free(p)
int len
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:380
FILE * out
Definition: movenc.c:54
#define av_freep(p)
void INT64 start
Definition: avisynth_c.h:766
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
int ff_isom_write_avcc(AVIOContext *pb, const uint8_t *data, int len)
Definition: avc.c:109
static av_always_inline int get_bitsz(GetBitContext *s, int n)
Read 0-25 bits.
Definition: get_bits.h:415
int avio_get_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1442