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 
29 static const uint8_t *ff_avc_find_startcode_internal(const uint8_t *p, const uint8_t *end)
30 {
31  const uint8_t *a = p + 4 - ((intptr_t)p & 3);
32 
33  for (end -= 3; p < a && p < end; p++) {
34  if (p[0] == 0 && p[1] == 0 && p[2] == 1)
35  return p;
36  }
37 
38  for (end -= 3; p < end; p += 4) {
39  uint32_t x = *(const uint32_t*)p;
40 // if ((x - 0x01000100) & (~x) & 0x80008000) // little endian
41 // if ((x - 0x00010001) & (~x) & 0x00800080) // big endian
42  if ((x - 0x01010101) & (~x) & 0x80808080) { // generic
43  if (p[1] == 0) {
44  if (p[0] == 0 && p[2] == 1)
45  return p;
46  if (p[2] == 0 && p[3] == 1)
47  return p+1;
48  }
49  if (p[3] == 0) {
50  if (p[2] == 0 && p[4] == 1)
51  return p+2;
52  if (p[4] == 0 && p[5] == 1)
53  return p+3;
54  }
55  }
56  }
57 
58  for (end += 3; p < end; p++) {
59  if (p[0] == 0 && p[1] == 0 && p[2] == 1)
60  return p;
61  }
62 
63  return end + 3;
64 }
65 
66 const uint8_t *ff_avc_find_startcode(const uint8_t *p, const uint8_t *end){
68  if(p<out && out<end && !out[-1]) out--;
69  return out;
70 }
71 
72 int ff_avc_parse_nal_units(AVIOContext *pb, const uint8_t *buf_in, int size)
73 {
74  const uint8_t *p = buf_in;
75  const uint8_t *end = p + size;
76  const uint8_t *nal_start, *nal_end;
77 
78  size = 0;
79  nal_start = ff_avc_find_startcode(p, end);
80  for (;;) {
81  while (nal_start < end && !*(nal_start++));
82  if (nal_start == end)
83  break;
84 
85  nal_end = ff_avc_find_startcode(nal_start, end);
86  avio_wb32(pb, nal_end - nal_start);
87  avio_write(pb, nal_start, nal_end - nal_start);
88  size += 4 + nal_end - nal_start;
89  nal_start = nal_end;
90  }
91  return size;
92 }
93 
94 int ff_avc_parse_nal_units_buf(const uint8_t *buf_in, uint8_t **buf, int *size)
95 {
96  AVIOContext *pb;
97  int ret = avio_open_dyn_buf(&pb);
98  if(ret < 0)
99  return ret;
100 
101  ff_avc_parse_nal_units(pb, buf_in, *size);
102 
103  av_freep(buf);
104  *size = avio_close_dyn_buf(pb, buf);
105  return 0;
106 }
107 
109 {
110  AVIOContext *sps_pb = NULL, *pps_pb = NULL;
111  uint8_t *buf = NULL, *end, *start = NULL;
112  uint8_t *sps = NULL, *pps = NULL;
113  uint32_t sps_size = 0, pps_size = 0;
114  int ret, nb_sps = 0, nb_pps = 0;
115 
116  if (len <= 6)
117  return AVERROR_INVALIDDATA;
118 
119  /* check for H.264 start code */
120  if (AV_RB32(data) != 0x00000001 &&
121  AV_RB24(data) != 0x000001) {
122  avio_write(pb, data, len);
123  return 0;
124  }
125 
126  ret = ff_avc_parse_nal_units_buf(data, &buf, &len);
127  if (ret < 0)
128  return ret;
129  start = buf;
130  end = buf + len;
131 
132  ret = avio_open_dyn_buf(&sps_pb);
133  if (ret < 0)
134  goto fail;
135  ret = avio_open_dyn_buf(&pps_pb);
136  if (ret < 0)
137  goto fail;
138 
139  /* look for sps and pps */
140  while (end - buf > 4) {
141  uint32_t size;
142  uint8_t nal_type;
143  size = FFMIN(AV_RB32(buf), end - buf - 4);
144  buf += 4;
145  nal_type = buf[0] & 0x1f;
146 
147  if (nal_type == 7) { /* SPS */
148  nb_sps++;
149  if (size > UINT16_MAX || nb_sps >= H264_MAX_SPS_COUNT) {
150  ret = AVERROR_INVALIDDATA;
151  goto fail;
152  }
153  avio_wb16(sps_pb, size);
154  avio_write(sps_pb, buf, size);
155  } else if (nal_type == 8) { /* PPS */
156  nb_pps++;
157  if (size > UINT16_MAX || nb_pps >= H264_MAX_PPS_COUNT) {
158  ret = AVERROR_INVALIDDATA;
159  goto fail;
160  }
161  avio_wb16(pps_pb, size);
162  avio_write(pps_pb, buf, size);
163  }
164 
165  buf += size;
166  }
167  sps_size = avio_close_dyn_buf(sps_pb, &sps);
168  pps_size = avio_close_dyn_buf(pps_pb, &pps);
169 
170  if (sps_size < 6 || !pps_size) {
171  ret = AVERROR_INVALIDDATA;
172  goto fail;
173  }
174 
175  avio_w8(pb, 1); /* version */
176  avio_w8(pb, sps[3]); /* profile */
177  avio_w8(pb, sps[4]); /* profile compat */
178  avio_w8(pb, sps[5]); /* level */
179  avio_w8(pb, 0xff); /* 6 bits reserved (111111) + 2 bits nal size length - 1 (11) */
180  avio_w8(pb, 0xe0 | nb_sps); /* 3 bits reserved (111) + 5 bits number of sps */
181 
182  avio_write(pb, sps, sps_size);
183  avio_w8(pb, nb_pps); /* number of pps */
184  avio_write(pb, pps, pps_size);
185 
186 fail:
187  if (!sps)
188  avio_close_dyn_buf(sps_pb, &sps);
189  if (!pps)
190  avio_close_dyn_buf(pps_pb, &pps);
191  av_free(sps);
192  av_free(pps);
193  av_free(start);
194 
195  return ret;
196 }
197 
199 {
200  uint16_t sps_size, pps_size;
201  uint8_t *out;
202  int out_size;
203 
204  *buf = NULL;
205  if (*size >= 4 && (AV_RB32(in) == 0x00000001 || AV_RB24(in) == 0x000001))
206  return 0;
207  if (*size < 11 || in[0] != 1)
208  return AVERROR_INVALIDDATA;
209 
210  sps_size = AV_RB16(&in[6]);
211  if (11 + sps_size > *size)
212  return AVERROR_INVALIDDATA;
213  pps_size = AV_RB16(&in[9 + sps_size]);
214  if (11 + sps_size + pps_size > *size)
215  return AVERROR_INVALIDDATA;
216  out_size = 8 + sps_size + pps_size;
217  out = av_mallocz(out_size + AV_INPUT_BUFFER_PADDING_SIZE);
218  if (!out)
219  return AVERROR(ENOMEM);
220  AV_WB32(&out[0], 0x00000001);
221  memcpy(out + 4, &in[8], sps_size);
222  AV_WB32(&out[4 + sps_size], 0x00000001);
223  memcpy(out + 8 + sps_size, &in[11 + sps_size], pps_size);
224  *buf = out;
225  *size = out_size;
226  return 0;
227 }
228 
230  const uint8_t *end,
231  int nal_length_size)
232 {
233  unsigned int res = 0;
234 
235  if (end - start < nal_length_size)
236  return NULL;
237  while (nal_length_size--)
238  res = (res << 8) | *start++;
239 
240  if (res > end - start)
241  return NULL;
242 
243  return start + res;
244 }
245 
246 uint8_t *ff_nal_unit_extract_rbsp(const uint8_t *src, uint32_t src_len,
247  uint32_t *dst_len, int header_len)
248 {
249  uint8_t *dst;
250  uint32_t i, len;
251 
252  dst = av_malloc(src_len + AV_INPUT_BUFFER_PADDING_SIZE);
253  if (!dst)
254  return NULL;
255 
256  /* NAL unit header */
257  i = len = 0;
258  while (i < header_len && i < src_len)
259  dst[len++] = src[i++];
260 
261  while (i + 2 < src_len)
262  if (!src[i] && !src[i + 1] && src[i + 2] == 3) {
263  dst[len++] = src[i++];
264  dst[len++] = src[i++];
265  i++; // remove emulation_prevention_three_byte
266  } else
267  dst[len++] = src[i++];
268 
269  while (i < src_len)
270  dst[len++] = src[i++];
271 
272  memset(dst + len, 0, AV_INPUT_BUFFER_PADDING_SIZE);
273 
274  *dst_len = len;
275  return dst;
276 }
277 
279  { 0, 1 },
280  { 1, 1 },
281  { 12, 11 },
282  { 10, 11 },
283  { 16, 11 },
284  { 40, 33 },
285  { 24, 11 },
286  { 20, 11 },
287  { 32, 11 },
288  { 80, 33 },
289  { 18, 11 },
290  { 15, 11 },
291  { 64, 33 },
292  { 160, 99 },
293  { 4, 3 },
294  { 3, 2 },
295  { 2, 1 },
296 };
297 
298 static inline int get_ue_golomb(GetBitContext *gb) {
299  int i;
300  for (i = 0; i < 32 && !get_bits1(gb); i++)
301  ;
302  return get_bitsz(gb, i) + (1 << i) - 1;
303 }
304 
305 static inline int get_se_golomb(GetBitContext *gb) {
306  int v = get_ue_golomb(gb) + 1;
307  int sign = -(v & 1);
308  return ((v >> 1) ^ sign) - sign;
309 }
310 
312 {
313  int i, j, ret, rbsp_size, aspect_ratio_idc, pic_order_cnt_type;
314  int num_ref_frames_in_pic_order_cnt_cycle;
315  int delta_scale, lastScale = 8, nextScale = 8;
316  int sizeOfScalingList;
318  GetBitContext gb;
319  uint8_t *rbsp_buf;
320 
321  rbsp_buf = ff_nal_unit_extract_rbsp(buf, buf_size, &rbsp_size, 0);
322  if (!rbsp_buf)
323  return NULL;
324 
325  ret = init_get_bits8(&gb, rbsp_buf, rbsp_size);
326  if (ret < 0)
327  goto end;
328 
329  sps = av_mallocz(sizeof(*sps));
330  if (!sps)
331  goto end;
332 
333  sps->profile_idc = get_bits(&gb, 8);
334  sps->constraint_set_flags |= get_bits1(&gb) << 0; // constraint_set0_flag
335  sps->constraint_set_flags |= get_bits1(&gb) << 1; // constraint_set1_flag
336  sps->constraint_set_flags |= get_bits1(&gb) << 2; // constraint_set2_flag
337  sps->constraint_set_flags |= get_bits1(&gb) << 3; // constraint_set3_flag
338  sps->constraint_set_flags |= get_bits1(&gb) << 4; // constraint_set4_flag
339  sps->constraint_set_flags |= get_bits1(&gb) << 5; // constraint_set5_flag
340  skip_bits(&gb, 2); // reserved_zero_2bits
341  sps->level_idc = get_bits(&gb, 8);
342  sps->id = get_ue_golomb(&gb);
343 
344  if (sps->profile_idc == 100 || sps->profile_idc == 110 ||
345  sps->profile_idc == 122 || sps->profile_idc == 244 || sps->profile_idc == 44 ||
346  sps->profile_idc == 83 || sps->profile_idc == 86 || sps->profile_idc == 118 ||
347  sps->profile_idc == 128 || sps->profile_idc == 138 || sps->profile_idc == 139 ||
348  sps->profile_idc == 134) {
349  sps->chroma_format_idc = get_ue_golomb(&gb); // chroma_format_idc
350  if (sps->chroma_format_idc == 3) {
351  skip_bits1(&gb); // separate_colour_plane_flag
352  }
353  sps->bit_depth_luma = get_ue_golomb(&gb) + 8;
354  get_ue_golomb(&gb); // bit_depth_chroma_minus8
355  skip_bits1(&gb); // qpprime_y_zero_transform_bypass_flag
356  if (get_bits1(&gb)) { // seq_scaling_matrix_present_flag
357  for (i = 0; i < ((sps->chroma_format_idc != 3) ? 8 : 12); i++) {
358  if (!get_bits1(&gb)) // seq_scaling_list_present_flag
359  continue;
360  lastScale = 8;
361  nextScale = 8;
362  sizeOfScalingList = i < 6 ? 16 : 64;
363  for (j = 0; j < sizeOfScalingList; j++) {
364  if (nextScale != 0) {
365  delta_scale = get_se_golomb(&gb);
366  nextScale = (lastScale + delta_scale) & 0xff;
367  }
368  lastScale = nextScale == 0 ? lastScale : nextScale;
369  }
370  }
371  }
372  } else {
373  sps->chroma_format_idc = 1;
374  sps->bit_depth_luma = 8;
375  }
376 
377  get_ue_golomb(&gb); // log2_max_frame_num_minus4
378  pic_order_cnt_type = get_ue_golomb(&gb);
379 
380  if (pic_order_cnt_type == 0) {
381  get_ue_golomb(&gb); // log2_max_pic_order_cnt_lsb_minus4
382  } else if (pic_order_cnt_type == 1) {
383  skip_bits1(&gb); // delta_pic_order_always_zero
384  get_se_golomb(&gb); // offset_for_non_ref_pic
385  get_se_golomb(&gb); // offset_for_top_to_bottom_field
386  num_ref_frames_in_pic_order_cnt_cycle = get_ue_golomb(&gb);
387  for (i = 0; i < num_ref_frames_in_pic_order_cnt_cycle; i++)
388  get_se_golomb(&gb); // offset_for_ref_frame
389  }
390 
391  get_ue_golomb(&gb); // max_num_ref_frames
392  skip_bits1(&gb); // gaps_in_frame_num_value_allowed_flag
393  get_ue_golomb(&gb); // pic_width_in_mbs_minus1
394  get_ue_golomb(&gb); // pic_height_in_map_units_minus1
395 
396  sps->frame_mbs_only_flag = get_bits1(&gb);
397  if (!sps->frame_mbs_only_flag)
398  skip_bits1(&gb); // mb_adaptive_frame_field_flag
399 
400  skip_bits1(&gb); // direct_8x8_inference_flag
401 
402  if (get_bits1(&gb)) { // frame_cropping_flag
403  get_ue_golomb(&gb); // frame_crop_left_offset
404  get_ue_golomb(&gb); // frame_crop_right_offset
405  get_ue_golomb(&gb); // frame_crop_top_offset
406  get_ue_golomb(&gb); // frame_crop_bottom_offset
407  }
408 
409  if (get_bits1(&gb)) { // vui_parameters_present_flag
410  if (get_bits1(&gb)) { // aspect_ratio_info_present_flag
411  aspect_ratio_idc = get_bits(&gb, 8);
412  if (aspect_ratio_idc == 0xff) {
413  sps->sar.num = get_bits(&gb, 16);
414  sps->sar.den = get_bits(&gb, 16);
415  } else if (aspect_ratio_idc < FF_ARRAY_ELEMS(avc_sample_aspect_ratio)) {
416  sps->sar = avc_sample_aspect_ratio[aspect_ratio_idc];
417  }
418  }
419  }
420 
421  if (!sps->sar.den) {
422  sps->sar.num = 1;
423  sps->sar.den = 1;
424  }
425 
426  end:
427  av_free(rbsp_buf);
428  return sps;
429 }
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:305
Buffered I/O operations.
const uint8_t * ff_avc_find_startcode(const uint8_t *p, const uint8_t *end)
Definition: avc.c:66
int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
Return the written size and a pointer to the buffer.
Definition: aviobuf.c:1459
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
static int get_ue_golomb(GetBitContext *gb)
Definition: avc.c:298
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:278
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:198
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:94
#define fail()
Definition: checkasm.h:120
int ff_avc_parse_nal_units(AVIOContext *pb, const uint8_t *buf_in, int size)
Definition: avc.c:72
#define FFMIN(a, b)
Definition: common.h:96
uint8_t frame_mbs_only_flag
Definition: avc.h:46
static const uint8_t * ff_avc_find_startcode_internal(const uint8_t *p, const uint8_t *end)
Definition: avc.c:29
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:246
#define FF_ARRAY_ELEMS(a)
AVRational sar
Definition: avc.h:47
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:229
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:311
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:790
#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:108
static av_always_inline int get_bitsz(GetBitContext *s, int n)
Read 0-25 bits.
Definition: get_bits.h:415