FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
utils.c
Go to the documentation of this file.
1 /*
2  * utils for libavcodec
3  * Copyright (c) 2001 Fabrice Bellard
4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * utils.
26  */
27 
28 #include "config.h"
29 #include "libavutil/attributes.h"
30 #include "libavutil/avassert.h"
31 #include "libavutil/avstring.h"
32 #include "libavutil/bprint.h"
33 #include "libavutil/channel_layout.h"
34 #include "libavutil/crc.h"
35 #include "libavutil/frame.h"
36 #include "libavutil/mathematics.h"
37 #include "libavutil/pixdesc.h"
38 #include "libavutil/imgutils.h"
39 #include "libavutil/samplefmt.h"
40 #include "libavutil/dict.h"
41 #include "libavutil/avassert.h"
42 #include "avcodec.h"
43 #include "dsputil.h"
44 #include "libavutil/opt.h"
45 #include "thread.h"
46 #include "frame_thread_encoder.h"
47 #include "internal.h"
48 #include "bytestream.h"
49 #include "version.h"
50 #include <stdlib.h>
51 #include <stdarg.h>
52 #include <limits.h>
53 #include <float.h>
54 #if CONFIG_ICONV
55 # include <iconv.h>
56 #endif
57 
58 volatile int ff_avcodec_locked;
59 static int volatile entangled_thread_counter = 0;
60 static int (*lockmgr_cb)(void **mutex, enum AVLockOp op);
61 static void *codec_mutex;
62 static void *avformat_mutex;
63 
64 void *av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
65 {
66  if (min_size < *size)
67  return ptr;
68 
69  min_size = FFMAX(17 * min_size / 16 + 32, min_size);
70 
71  ptr = av_realloc(ptr, min_size);
72  /* we could set this to the unmodified min_size but this is safer
73  * if the user lost the ptr and uses NULL now
74  */
75  if (!ptr)
76  min_size = 0;
77 
78  *size = min_size;
79 
80  return ptr;
81 }
82 
83 static inline int ff_fast_malloc(void *ptr, unsigned int *size, size_t min_size, int zero_realloc)
84 {
85  void **p = ptr;
86  if (min_size < *size)
87  return 0;
88  min_size = FFMAX(17 * min_size / 16 + 32, min_size);
89  av_free(*p);
90  *p = zero_realloc ? av_mallocz(min_size) : av_malloc(min_size);
91  if (!*p)
92  min_size = 0;
93  *size = min_size;
94  return 1;
95 }
96 
97 void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
98 {
99  ff_fast_malloc(ptr, size, min_size, 0);
100 }
101 
102 void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
103 {
104  uint8_t **p = ptr;
105  if (min_size > SIZE_MAX - FF_INPUT_BUFFER_PADDING_SIZE) {
106  av_freep(p);
107  *size = 0;
108  return;
109  }
110  if (!ff_fast_malloc(p, size, min_size + FF_INPUT_BUFFER_PADDING_SIZE, 1))
111  memset(*p + min_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
112 }
113 
114 void av_fast_padded_mallocz(void *ptr, unsigned int *size, size_t min_size)
115 {
116  uint8_t **p = ptr;
117  if (min_size > SIZE_MAX - FF_INPUT_BUFFER_PADDING_SIZE) {
118  av_freep(p);
119  *size = 0;
120  return;
121  }
122  if (!ff_fast_malloc(p, size, min_size + FF_INPUT_BUFFER_PADDING_SIZE, 1))
123  memset(*p, 0, min_size + FF_INPUT_BUFFER_PADDING_SIZE);
124 }
125 
126 /* encoder management */
127 static AVCodec *first_avcodec = NULL;
128 
129 AVCodec *av_codec_next(const AVCodec *c)
130 {
131  if (c)
132  return c->next;
133  else
134  return first_avcodec;
135 }
136 
137 static av_cold void avcodec_init(void)
138 {
139  static int initialized = 0;
140 
141  if (initialized != 0)
142  return;
143  initialized = 1;
144 
145  if (CONFIG_DSPUTIL)
146  ff_dsputil_static_init();
147 }
148 
149 int av_codec_is_encoder(const AVCodec *codec)
150 {
151  return codec && (codec->encode_sub || codec->encode2);
152 }
153 
154 int av_codec_is_decoder(const AVCodec *codec)
155 {
156  return codec && codec->decode;
157 }
158 
159 av_cold void avcodec_register(AVCodec *codec)
160 {
161  AVCodec **p;
162  avcodec_init();
163  p = &first_avcodec;
164  while (*p != NULL)
165  p = &(*p)->next;
166  *p = codec;
167  codec->next = NULL;
168 
169  if (codec->init_static_data)
170  codec->init_static_data(codec);
171 }
172 
173 unsigned avcodec_get_edge_width(void)
174 {
175  return EDGE_WIDTH;
176 }
177 
178 void avcodec_set_dimensions(AVCodecContext *s, int width, int height)
179 {
180  s->coded_width = width;
181  s->coded_height = height;
182  s->width = FF_CEIL_RSHIFT(width, s->lowres);
183  s->height = FF_CEIL_RSHIFT(height, s->lowres);
184 }
185 
186 #if (ARCH_ARM && HAVE_NEON) || ARCH_PPC || HAVE_MMX
187 # define STRIDE_ALIGN 16
188 #else
189 # define STRIDE_ALIGN 8
190 #endif
191 
192 void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height,
193  int linesize_align[AV_NUM_DATA_POINTERS])
194 {
195  int i;
196  int w_align = 1;
197  int h_align = 1;
198 
199  switch (s->pix_fmt) {
200  case AV_PIX_FMT_YUV420P:
201  case AV_PIX_FMT_YUYV422:
202  case AV_PIX_FMT_UYVY422:
203  case AV_PIX_FMT_YUV422P:
204  case AV_PIX_FMT_YUV440P:
205  case AV_PIX_FMT_YUV444P:
206  case AV_PIX_FMT_GBRAP:
207  case AV_PIX_FMT_GBRP:
208  case AV_PIX_FMT_GRAY8:
209  case AV_PIX_FMT_GRAY16BE:
210  case AV_PIX_FMT_GRAY16LE:
211  case AV_PIX_FMT_YUVJ420P:
212  case AV_PIX_FMT_YUVJ422P:
213  case AV_PIX_FMT_YUVJ440P:
214  case AV_PIX_FMT_YUVJ444P:
215  case AV_PIX_FMT_YUVA420P:
216  case AV_PIX_FMT_YUVA422P:
217  case AV_PIX_FMT_YUVA444P:
218  case AV_PIX_FMT_YUV420P9LE:
219  case AV_PIX_FMT_YUV420P9BE:
220  case AV_PIX_FMT_YUV420P10LE:
221  case AV_PIX_FMT_YUV420P10BE:
222  case AV_PIX_FMT_YUV420P12LE:
223  case AV_PIX_FMT_YUV420P12BE:
224  case AV_PIX_FMT_YUV420P14LE:
225  case AV_PIX_FMT_YUV420P14BE:
226  case AV_PIX_FMT_YUV422P9LE:
227  case AV_PIX_FMT_YUV422P9BE:
228  case AV_PIX_FMT_YUV422P10LE:
229  case AV_PIX_FMT_YUV422P10BE:
230  case AV_PIX_FMT_YUV422P12LE:
231  case AV_PIX_FMT_YUV422P12BE:
232  case AV_PIX_FMT_YUV422P14LE:
233  case AV_PIX_FMT_YUV422P14BE:
234  case AV_PIX_FMT_YUV444P9LE:
235  case AV_PIX_FMT_YUV444P9BE:
236  case AV_PIX_FMT_YUV444P10LE:
237  case AV_PIX_FMT_YUV444P10BE:
238  case AV_PIX_FMT_YUV444P12LE:
239  case AV_PIX_FMT_YUV444P12BE:
240  case AV_PIX_FMT_YUV444P14LE:
241  case AV_PIX_FMT_YUV444P14BE:
242  case AV_PIX_FMT_YUVA420P9LE:
243  case AV_PIX_FMT_YUVA420P9BE:
244  case AV_PIX_FMT_YUVA420P10LE:
245  case AV_PIX_FMT_YUVA420P10BE:
246  case AV_PIX_FMT_YUVA422P9LE:
247  case AV_PIX_FMT_YUVA422P9BE:
248  case AV_PIX_FMT_YUVA422P10LE:
249  case AV_PIX_FMT_YUVA422P10BE:
250  case AV_PIX_FMT_YUVA444P9LE:
251  case AV_PIX_FMT_YUVA444P9BE:
252  case AV_PIX_FMT_YUVA444P10LE:
253  case AV_PIX_FMT_YUVA444P10BE:
254  case AV_PIX_FMT_GBRP9LE:
255  case AV_PIX_FMT_GBRP9BE:
256  case AV_PIX_FMT_GBRP10LE:
257  case AV_PIX_FMT_GBRP10BE:
258  case AV_PIX_FMT_GBRP12LE:
259  case AV_PIX_FMT_GBRP12BE:
260  case AV_PIX_FMT_GBRP14LE:
261  case AV_PIX_FMT_GBRP14BE:
262  w_align = 16; //FIXME assume 16 pixel per macroblock
263  h_align = 16 * 2; // interlaced needs 2 macroblocks height
264  break;
265  case AV_PIX_FMT_YUV411P:
266  case AV_PIX_FMT_YUVJ411P:
267  case AV_PIX_FMT_UYYVYY411:
268  w_align = 32;
269  h_align = 8;
270  break;
271  case AV_PIX_FMT_YUV410P:
272  if (s->codec_id == AV_CODEC_ID_SVQ1) {
273  w_align = 64;
274  h_align = 64;
275  }
276  break;
277  case AV_PIX_FMT_RGB555:
278  if (s->codec_id == AV_CODEC_ID_RPZA) {
279  w_align = 4;
280  h_align = 4;
281  }
282  break;
283  case AV_PIX_FMT_PAL8:
284  case AV_PIX_FMT_BGR8:
285  case AV_PIX_FMT_RGB8:
286  if (s->codec_id == AV_CODEC_ID_SMC ||
287  s->codec_id == AV_CODEC_ID_CINEPAK) {
288  w_align = 4;
289  h_align = 4;
290  }
291  break;
292  case AV_PIX_FMT_BGR24:
293  if ((s->codec_id == AV_CODEC_ID_MSZH) ||
294  (s->codec_id == AV_CODEC_ID_ZLIB)) {
295  w_align = 4;
296  h_align = 4;
297  }
298  break;
299  case AV_PIX_FMT_RGB24:
300  if (s->codec_id == AV_CODEC_ID_CINEPAK) {
301  w_align = 4;
302  h_align = 4;
303  }
304  break;
305  default:
306  w_align = 1;
307  h_align = 1;
308  break;
309  }
310 
311  if (s->codec_id == AV_CODEC_ID_IFF_ILBM || s->codec_id == AV_CODEC_ID_IFF_BYTERUN1) {
312  w_align = FFMAX(w_align, 8);
313  }
314 
315  *width = FFALIGN(*width, w_align);
316  *height = FFALIGN(*height, h_align);
317  if (s->codec_id == AV_CODEC_ID_H264 || s->lowres)
318  // some of the optimized chroma MC reads one line too much
319  // which is also done in mpeg decoders with lowres > 0
320  *height += 2;
321 
322  for (i = 0; i < 4; i++)
323  linesize_align[i] = STRIDE_ALIGN;
324 }
325 
326 void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height)
327 {
328  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->pix_fmt);
329  int chroma_shift = desc->log2_chroma_w;
330  int linesize_align[AV_NUM_DATA_POINTERS];
331  int align;
332 
333  avcodec_align_dimensions2(s, width, height, linesize_align);
334  align = FFMAX(linesize_align[0], linesize_align[3]);
335  linesize_align[1] <<= chroma_shift;
336  linesize_align[2] <<= chroma_shift;
337  align = FFMAX3(align, linesize_align[1], linesize_align[2]);
338  *width = FFALIGN(*width, align);
339 }
340 
341 int avcodec_fill_audio_frame(AVFrame *frame, int nb_channels,
342  enum AVSampleFormat sample_fmt, const uint8_t *buf,
343  int buf_size, int align)
344 {
345  int ch, planar, needed_size, ret = 0;
346 
347  needed_size = av_samples_get_buffer_size(NULL, nb_channels,
348  frame->nb_samples, sample_fmt,
349  align);
350  if (buf_size < needed_size)
351  return AVERROR(EINVAL);
352 
353  planar = av_sample_fmt_is_planar(sample_fmt);
354  if (planar && nb_channels > AV_NUM_DATA_POINTERS) {
355  if (!(frame->extended_data = av_mallocz(nb_channels *
356  sizeof(*frame->extended_data))))
357  return AVERROR(ENOMEM);
358  } else {
359  frame->extended_data = frame->data;
360  }
361 
362  if ((ret = av_samples_fill_arrays(frame->extended_data, &frame->linesize[0],
363  (uint8_t *)(intptr_t)buf, nb_channels, frame->nb_samples,
364  sample_fmt, align)) < 0) {
365  if (frame->extended_data != frame->data)
366  av_freep(&frame->extended_data);
367  return ret;
368  }
369  if (frame->extended_data != frame->data) {
370  for (ch = 0; ch < AV_NUM_DATA_POINTERS; ch++)
371  frame->data[ch] = frame->extended_data[ch];
372  }
373 
374  return ret;
375 }
376 
377 static int update_frame_pool(AVCodecContext *avctx, AVFrame *frame)
378 {
379  FramePool *pool = avctx->internal->pool;
380  int i, ret;
381 
382  switch (avctx->codec_type) {
383  case AVMEDIA_TYPE_VIDEO: {
384  AVPicture picture;
385  int size[4] = { 0 };
386  int w = frame->width;
387  int h = frame->height;
388  int tmpsize, unaligned;
389 
390  if (pool->format == frame->format &&
391  pool->width == frame->width && pool->height == frame->height)
392  return 0;
393 
394  avcodec_align_dimensions2(avctx, &w, &h, pool->stride_align);
395 
396  if (!(avctx->flags & CODEC_FLAG_EMU_EDGE)) {
397  w += EDGE_WIDTH * 2;
398  h += EDGE_WIDTH * 2;
399  }
400 
401  do {
402  // NOTE: do not align linesizes individually, this breaks e.g. assumptions
403  // that linesize[0] == 2*linesize[1] in the MPEG-encoder for 4:2:2
404  av_image_fill_linesizes(picture.linesize, avctx->pix_fmt, w);
405  // increase alignment of w for next try (rhs gives the lowest bit set in w)
406  w += w & ~(w - 1);
407 
408  unaligned = 0;
409  for (i = 0; i < 4; i++)
410  unaligned |= picture.linesize[i] % pool->stride_align[i];
411  } while (unaligned);
412 
413  tmpsize = av_image_fill_pointers(picture.data, avctx->pix_fmt, h,
414  NULL, picture.linesize);
415  if (tmpsize < 0)
416  return -1;
417 
418  for (i = 0; i < 3 && picture.data[i + 1]; i++)
419  size[i] = picture.data[i + 1] - picture.data[i];
420  size[i] = tmpsize - (picture.data[i] - picture.data[0]);
421 
422  for (i = 0; i < 4; i++) {
423  av_buffer_pool_uninit(&pool->pools[i]);
424  pool->linesize[i] = picture.linesize[i];
425  if (size[i]) {
426  pool->pools[i] = av_buffer_pool_init(size[i] + 16,
427  CONFIG_MEMORY_POISONING ?
428  NULL :
429  av_buffer_allocz);
430  if (!pool->pools[i]) {
431  ret = AVERROR(ENOMEM);
432  goto fail;
433  }
434  }
435  }
436  pool->format = frame->format;
437  pool->width = frame->width;
438  pool->height = frame->height;
439 
440  break;
441  }
442  case AVMEDIA_TYPE_AUDIO: {
443  int ch = av_frame_get_channels(frame); //av_get_channel_layout_nb_channels(frame->channel_layout);
444  int planar = av_sample_fmt_is_planar(frame->format);
445  int planes = planar ? ch : 1;
446 
447  if (pool->format == frame->format && pool->planes == planes &&
448  pool->channels == ch && frame->nb_samples == pool->samples)
449  return 0;
450 
451  av_buffer_pool_uninit(&pool->pools[0]);
452  ret = av_samples_get_buffer_size(&pool->linesize[0], ch,
453  frame->nb_samples, frame->format, 0);
454  if (ret < 0)
455  goto fail;
456 
457  pool->pools[0] = av_buffer_pool_init(pool->linesize[0], NULL);
458  if (!pool->pools[0]) {
459  ret = AVERROR(ENOMEM);
460  goto fail;
461  }
462 
463  pool->format = frame->format;
464  pool->planes = planes;
465  pool->channels = ch;
466  pool->samples = frame->nb_samples;
467  break;
468  }
469  default: av_assert0(0);
470  }
471  return 0;
472 fail:
473  for (i = 0; i < 4; i++)
474  av_buffer_pool_uninit(&pool->pools[i]);
475  pool->format = -1;
476  pool->planes = pool->channels = pool->samples = 0;
477  pool->width = pool->height = 0;
478  return ret;
479 }
480 
481 static int audio_get_buffer(AVCodecContext *avctx, AVFrame *frame)
482 {
483  FramePool *pool = avctx->internal->pool;
484  int planes = pool->planes;
485  int i;
486 
487  frame->linesize[0] = pool->linesize[0];
488 
489  if (planes > AV_NUM_DATA_POINTERS) {
490  frame->extended_data = av_mallocz(planes * sizeof(*frame->extended_data));
491  frame->nb_extended_buf = planes - AV_NUM_DATA_POINTERS;
492  frame->extended_buf = av_mallocz(frame->nb_extended_buf *
493  sizeof(*frame->extended_buf));
494  if (!frame->extended_data || !frame->extended_buf) {
495  av_freep(&frame->extended_data);
496  av_freep(&frame->extended_buf);
497  return AVERROR(ENOMEM);
498  }
499  } else {
500  frame->extended_data = frame->data;
501  av_assert0(frame->nb_extended_buf == 0);
502  }
503 
504  for (i = 0; i < FFMIN(planes, AV_NUM_DATA_POINTERS); i++) {
505  frame->buf[i] = av_buffer_pool_get(pool->pools[0]);
506  if (!frame->buf[i])
507  goto fail;
508  frame->extended_data[i] = frame->data[i] = frame->buf[i]->data;
509  }
510  for (i = 0; i < frame->nb_extended_buf; i++) {
511  frame->extended_buf[i] = av_buffer_pool_get(pool->pools[0]);
512  if (!frame->extended_buf[i])
513  goto fail;
514  frame->extended_data[i + AV_NUM_DATA_POINTERS] = frame->extended_buf[i]->data;
515  }
516 
517  if (avctx->debug & FF_DEBUG_BUFFERS)
518  av_log(avctx, AV_LOG_DEBUG, "default_get_buffer called on frame %p", frame);
519 
520  return 0;
521 fail:
522  av_frame_unref(frame);
523  return AVERROR(ENOMEM);
524 }
525 
526 static int video_get_buffer(AVCodecContext *s, AVFrame *pic)
527 {
528  FramePool *pool = s->internal->pool;
529  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pic->format);
530  int pixel_size = desc->comp[0].step_minus1 + 1;
531  int h_chroma_shift, v_chroma_shift;
532  int i;
533 
534  if (pic->data[0] != NULL) {
535  av_log(s, AV_LOG_ERROR, "pic->data[0]!=NULL in avcodec_default_get_buffer\n");
536  return -1;
537  }
538 
539  memset(pic->data, 0, sizeof(pic->data));
540  pic->extended_data = pic->data;
541 
542  av_pix_fmt_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);
543 
544  for (i = 0; i < 4 && pool->pools[i]; i++) {
545  const int h_shift = i == 0 ? 0 : h_chroma_shift;
546  const int v_shift = i == 0 ? 0 : v_chroma_shift;
547 
548  pic->linesize[i] = pool->linesize[i];
549 
550  pic->buf[i] = av_buffer_pool_get(pool->pools[i]);
551  if (!pic->buf[i])
552  goto fail;
553 
554  // no edge if EDGE EMU or not planar YUV
555  if ((s->flags & CODEC_FLAG_EMU_EDGE) || !pool->pools[2])
556  pic->data[i] = pic->buf[i]->data;
557  else {
558  pic->data[i] = pic->buf[i]->data +
559  FFALIGN((pic->linesize[i] * EDGE_WIDTH >> v_shift) +
560  (pixel_size * EDGE_WIDTH >> h_shift), pool->stride_align[i]);
561  }
562  }
563  for (; i < AV_NUM_DATA_POINTERS; i++) {
564  pic->data[i] = NULL;
565  pic->linesize[i] = 0;
566  }
567  if (pic->data[1] && !pic->data[2])
568  avpriv_set_systematic_pal2((uint32_t *)pic->data[1], s->pix_fmt);
569 
570  if (s->debug & FF_DEBUG_BUFFERS)
571  av_log(s, AV_LOG_DEBUG, "default_get_buffer called on pic %p\n", pic);
572 
573  return 0;
574 fail:
575  av_frame_unref(pic);
576  return AVERROR(ENOMEM);
577 }
578 
579 void avpriv_color_frame(AVFrame *frame, const int c[4])
580 {
581  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
582  int p, y, x;
583 
584  av_assert0(desc->flags & AV_PIX_FMT_FLAG_PLANAR);
585 
586  for (p = 0; p<desc->nb_components; p++) {
587  uint8_t *dst = frame->data[p];
588  int is_chroma = p == 1 || p == 2;
589  int bytes = is_chroma ? FF_CEIL_RSHIFT(frame->width, desc->log2_chroma_w) : frame->width;
590  int height = is_chroma ? FF_CEIL_RSHIFT(frame->height, desc->log2_chroma_h) : frame->height;
591  for (y = 0; y < height; y++) {
592  if (desc->comp[0].depth_minus1 >= 8) {
593  for (x = 0; x<bytes; x++)
594  ((uint16_t*)dst)[x] = c[p];
595  }else
596  memset(dst, c[p], bytes);
597  dst += frame->linesize[p];
598  }
599  }
600 }
601 
602 int avcodec_default_get_buffer2(AVCodecContext *avctx, AVFrame *frame, int flags)
603 {
604  int ret;
605 
606  if ((ret = update_frame_pool(avctx, frame)) < 0)
607  return ret;
608 
609 #if FF_API_GET_BUFFER
610  frame->type = FF_BUFFER_TYPE_INTERNAL;
611 #endif
612 
613  switch (avctx->codec_type) {
614  case AVMEDIA_TYPE_VIDEO:
615  return video_get_buffer(avctx, frame);
616  case AVMEDIA_TYPE_AUDIO:
617  return audio_get_buffer(avctx, frame);
618  default:
619  return -1;
620  }
621 }
622 
623 int ff_init_buffer_info(AVCodecContext *avctx, AVFrame *frame)
624 {
625  if (avctx->pkt) {
626  frame->pkt_pts = avctx->pkt->pts;
627  av_frame_set_pkt_pos (frame, avctx->pkt->pos);
628  av_frame_set_pkt_duration(frame, avctx->pkt->duration);
629  av_frame_set_pkt_size (frame, avctx->pkt->size);
630  } else {
631  frame->pkt_pts = AV_NOPTS_VALUE;
632  av_frame_set_pkt_pos (frame, -1);
633  av_frame_set_pkt_duration(frame, 0);
634  av_frame_set_pkt_size (frame, -1);
635  }
636  frame->reordered_opaque = avctx->reordered_opaque;
637 
638  switch (avctx->codec->type) {
639  case AVMEDIA_TYPE_VIDEO:
640  frame->width = FFMAX(avctx->width, FF_CEIL_RSHIFT(avctx->coded_width, avctx->lowres));
641  frame->height = FFMAX(avctx->height, FF_CEIL_RSHIFT(avctx->coded_height, avctx->lowres));
642  if (frame->format < 0)
643  frame->format = avctx->pix_fmt;
644  if (!frame->sample_aspect_ratio.num)
645  frame->sample_aspect_ratio = avctx->sample_aspect_ratio;
646  break;
647  case AVMEDIA_TYPE_AUDIO:
648  if (!frame->sample_rate)
649  frame->sample_rate = avctx->sample_rate;
650  if (frame->format < 0)
651  frame->format = avctx->sample_fmt;
652  if (!frame->channel_layout) {
653  if (avctx->channel_layout) {
654  if (av_get_channel_layout_nb_channels(avctx->channel_layout) !=
655  avctx->channels) {
656  av_log(avctx, AV_LOG_ERROR, "Inconsistent channel "
657  "configuration.\n");
658  return AVERROR(EINVAL);
659  }
660 
661  frame->channel_layout = avctx->channel_layout;
662  } else {
663  if (avctx->channels > FF_SANE_NB_CHANNELS) {
664  av_log(avctx, AV_LOG_ERROR, "Too many channels: %d.\n",
665  avctx->channels);
666  return AVERROR(ENOSYS);
667  }
668  }
669  }
670  av_frame_set_channels(frame, avctx->channels);
671  break;
672  }
673  return 0;
674 }
675 
676 #if FF_API_GET_BUFFER
677 int avcodec_default_get_buffer(AVCodecContext *avctx, AVFrame *frame)
678 {
679  return avcodec_default_get_buffer2(avctx, frame, 0);
680 }
681 
682 typedef struct CompatReleaseBufPriv {
683  AVCodecContext avctx;
684  AVFrame frame;
685 } CompatReleaseBufPriv;
686 
687 static void compat_free_buffer(void *opaque, uint8_t *data)
688 {
689  CompatReleaseBufPriv *priv = opaque;
690  if (priv->avctx.release_buffer)
691  priv->avctx.release_buffer(&priv->avctx, &priv->frame);
692  av_freep(&priv);
693 }
694 
695 static void compat_release_buffer(void *opaque, uint8_t *data)
696 {
697  AVBufferRef *buf = opaque;
698  av_buffer_unref(&buf);
699 }
700 #endif
701 
702 static int get_buffer_internal(AVCodecContext *avctx, AVFrame *frame, int flags)
703 {
704  int ret;
705 
706  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
707  if ((ret = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0 || avctx->pix_fmt<0) {
708  av_log(avctx, AV_LOG_ERROR, "video_get_buffer: image parameters invalid\n");
709  return AVERROR(EINVAL);
710  }
711  }
712  if ((ret = ff_init_buffer_info(avctx, frame)) < 0)
713  return ret;
714 
715 #if FF_API_GET_BUFFER
716  /*
717  * Wrap an old get_buffer()-allocated buffer in an bunch of AVBuffers.
718  * We wrap each plane in its own AVBuffer. Each of those has a reference to
719  * a dummy AVBuffer as its private data, unreffing it on free.
720  * When all the planes are freed, the dummy buffer's free callback calls
721  * release_buffer().
722  */
723  if (avctx->get_buffer) {
724  CompatReleaseBufPriv *priv = NULL;
725  AVBufferRef *dummy_buf = NULL;
726  int planes, i, ret;
727 
728  if (flags & AV_GET_BUFFER_FLAG_REF)
729  frame->reference = 1;
730 
731  ret = avctx->get_buffer(avctx, frame);
732  if (ret < 0)
733  return ret;
734 
735  /* return if the buffers are already set up
736  * this would happen e.g. when a custom get_buffer() calls
737  * avcodec_default_get_buffer
738  */
739  if (frame->buf[0])
740  goto end;
741 
742  priv = av_mallocz(sizeof(*priv));
743  if (!priv) {
744  ret = AVERROR(ENOMEM);
745  goto fail;
746  }
747  priv->avctx = *avctx;
748  priv->frame = *frame;
749 
750  dummy_buf = av_buffer_create(NULL, 0, compat_free_buffer, priv, 0);
751  if (!dummy_buf) {
752  ret = AVERROR(ENOMEM);
753  goto fail;
754  }
755 
756 #define WRAP_PLANE(ref_out, data, data_size) \
757 do { \
758  AVBufferRef *dummy_ref = av_buffer_ref(dummy_buf); \
759  if (!dummy_ref) { \
760  ret = AVERROR(ENOMEM); \
761  goto fail; \
762  } \
763  ref_out = av_buffer_create(data, data_size, compat_release_buffer, \
764  dummy_ref, 0); \
765  if (!ref_out) { \
766  av_frame_unref(frame); \
767  ret = AVERROR(ENOMEM); \
768  goto fail; \
769  } \
770 } while (0)
771 
772  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
773  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
774 
775  planes = av_pix_fmt_count_planes(frame->format);
776  /* workaround for AVHWAccel plane count of 0, buf[0] is used as
777  check for allocated buffers: make libavcodec happy */
778  if (desc && desc->flags & AV_PIX_FMT_FLAG_HWACCEL)
779  planes = 1;
780  if (!desc || planes <= 0) {
781  ret = AVERROR(EINVAL);
782  goto fail;
783  }
784 
785  for (i = 0; i < planes; i++) {
786  int v_shift = (i == 1 || i == 2) ? desc->log2_chroma_h : 0;
787  int plane_size = (frame->height >> v_shift) * frame->linesize[i];
788 
789  WRAP_PLANE(frame->buf[i], frame->data[i], plane_size);
790  }
791  } else {
792  int planar = av_sample_fmt_is_planar(frame->format);
793  planes = planar ? avctx->channels : 1;
794 
795  if (planes > FF_ARRAY_ELEMS(frame->buf)) {
796  frame->nb_extended_buf = planes - FF_ARRAY_ELEMS(frame->buf);
797  frame->extended_buf = av_malloc(sizeof(*frame->extended_buf) *
798  frame->nb_extended_buf);
799  if (!frame->extended_buf) {
800  ret = AVERROR(ENOMEM);
801  goto fail;
802  }
803  }
804 
805  for (i = 0; i < FFMIN(planes, FF_ARRAY_ELEMS(frame->buf)); i++)
806  WRAP_PLANE(frame->buf[i], frame->extended_data[i], frame->linesize[0]);
807 
808  for (i = 0; i < frame->nb_extended_buf; i++)
809  WRAP_PLANE(frame->extended_buf[i],
810  frame->extended_data[i + FF_ARRAY_ELEMS(frame->buf)],
811  frame->linesize[0]);
812  }
813 
814  av_buffer_unref(&dummy_buf);
815 
816 end:
817  frame->width = avctx->width;
818  frame->height = avctx->height;
819 
820  return 0;
821 
822 fail:
823  avctx->release_buffer(avctx, frame);
824  av_freep(&priv);
825  av_buffer_unref(&dummy_buf);
826  return ret;
827  }
828 #endif
829 
830  ret = avctx->get_buffer2(avctx, frame, flags);
831 
832  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
833  frame->width = avctx->width;
834  frame->height = avctx->height;
835  }
836 
837  return ret;
838 }
839 
840 int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
841 {
842  int ret = get_buffer_internal(avctx, frame, flags);
843  if (ret < 0)
844  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
845  return ret;
846 }
847 
848 static int reget_buffer_internal(AVCodecContext *avctx, AVFrame *frame)
849 {
850  AVFrame tmp;
851  int ret;
852 
853  av_assert0(avctx->codec_type == AVMEDIA_TYPE_VIDEO);
854 
855  if (frame->data[0] && (frame->width != avctx->width || frame->height != avctx->height || frame->format != avctx->pix_fmt)) {
856  av_log(avctx, AV_LOG_WARNING, "Picture changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s in reget buffer()\n",
857  frame->width, frame->height, av_get_pix_fmt_name(frame->format), avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
858  av_frame_unref(frame);
859  }
860 
861  ff_init_buffer_info(avctx, frame);
862 
863  if (!frame->data[0])
864  return ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF);
865 
866  if (av_frame_is_writable(frame))
867  return 0;
868 
869  av_frame_move_ref(&tmp, frame);
870 
871  ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF);
872  if (ret < 0) {
873  av_frame_unref(&tmp);
874  return ret;
875  }
876 
877  av_image_copy(frame->data, frame->linesize, tmp.data, tmp.linesize,
878  frame->format, frame->width, frame->height);
879 
880  av_frame_unref(&tmp);
881 
882  return 0;
883 }
884 
885 int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame)
886 {
887  int ret = reget_buffer_internal(avctx, frame);
888  if (ret < 0)
889  av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
890  return ret;
891 }
892 
893 #if FF_API_GET_BUFFER
894 void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic)
895 {
896  av_assert0(s->codec_type == AVMEDIA_TYPE_VIDEO);
897 
898  av_frame_unref(pic);
899 }
900 
901 int avcodec_default_reget_buffer(AVCodecContext *s, AVFrame *pic)
902 {
903  av_assert0(0);
904  return AVERROR_BUG;
905 }
906 #endif
907 
908 int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2), void *arg, int *ret, int count, int size)
909 {
910  int i;
911 
912  for (i = 0; i < count; i++) {
913  int r = func(c, (char *)arg + i * size);
914  if (ret)
915  ret[i] = r;
916  }
917  return 0;
918 }
919 
920 int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int jobnr, int threadnr), void *arg, int *ret, int count)
921 {
922  int i;
923 
924  for (i = 0; i < count; i++) {
925  int r = func(c, arg, i, 0);
926  if (ret)
927  ret[i] = r;
928  }
929  return 0;
930 }
931 
932 static int is_hwaccel_pix_fmt(enum AVPixelFormat pix_fmt)
933 {
934  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
935  return desc->flags & AV_PIX_FMT_FLAG_HWACCEL;
936 }
937 
938 enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum AVPixelFormat *fmt)
939 {
940  while (*fmt != AV_PIX_FMT_NONE && is_hwaccel_pix_fmt(*fmt))
941  ++fmt;
942  return fmt[0];
943 }
944 
945 void avcodec_get_frame_defaults(AVFrame *frame)
946 {
947 #if LIBAVCODEC_VERSION_MAJOR >= 55
948  // extended_data should explicitly be freed when needed, this code is unsafe currently
949  // also this is not compatible to the <55 ABI/API
950  if (frame->extended_data != frame->data && 0)
951  av_freep(&frame->extended_data);
952 #endif
953 
954  memset(frame, 0, sizeof(AVFrame));
955 
956  frame->pts =
957  frame->pkt_dts =
958  frame->pkt_pts = AV_NOPTS_VALUE;
959  av_frame_set_best_effort_timestamp(frame, AV_NOPTS_VALUE);
960  av_frame_set_pkt_duration (frame, 0);
961  av_frame_set_pkt_pos (frame, -1);
962  av_frame_set_pkt_size (frame, -1);
963  frame->key_frame = 1;
964  frame->sample_aspect_ratio = (AVRational) {0, 1 };
965  frame->format = -1; /* unknown */
966  frame->extended_data = frame->data;
967 }
968 
969 AVFrame *avcodec_alloc_frame(void)
970 {
971  AVFrame *frame = av_malloc(sizeof(AVFrame));
972 
973  if (frame == NULL)
974  return NULL;
975 
976  frame->extended_data = NULL;
977  avcodec_get_frame_defaults(frame);
978 
979  return frame;
980 }
981 
982 void avcodec_free_frame(AVFrame **frame)
983 {
984  AVFrame *f;
985 
986  if (!frame || !*frame)
987  return;
988 
989  f = *frame;
990 
991  if (f->extended_data != f->data)
992  av_freep(&f->extended_data);
993 
994  av_freep(frame);
995 }
996 
997 #define MAKE_ACCESSORS(str, name, type, field) \
998  type av_##name##_get_##field(const str *s) { return s->field; } \
999  void av_##name##_set_##field(str *s, type v) { s->field = v; }
1000 
1001 MAKE_ACCESSORS(AVCodecContext, codec, AVRational, pkt_timebase)
1002 MAKE_ACCESSORS(AVCodecContext, codec, const AVCodecDescriptor *, codec_descriptor)
1003 MAKE_ACCESSORS(AVCodecContext, codec, int, lowres)
1004 
1005 static void avcodec_get_subtitle_defaults(AVSubtitle *sub)
1006 {
1007  memset(sub, 0, sizeof(*sub));
1008  sub->pts = AV_NOPTS_VALUE;
1009 }
1010 
1011 static int get_bit_rate(AVCodecContext *ctx)
1012 {
1013  int bit_rate;
1014  int bits_per_sample;
1015 
1016  switch (ctx->codec_type) {
1017  case AVMEDIA_TYPE_VIDEO:
1018  case AVMEDIA_TYPE_DATA:
1019  case AVMEDIA_TYPE_SUBTITLE:
1020  case AVMEDIA_TYPE_ATTACHMENT:
1021  bit_rate = ctx->bit_rate;
1022  break;
1023  case AVMEDIA_TYPE_AUDIO:
1024  bits_per_sample = av_get_bits_per_sample(ctx->codec_id);
1025  bit_rate = bits_per_sample ? ctx->sample_rate * ctx->channels * bits_per_sample : ctx->bit_rate;
1026  break;
1027  default:
1028  bit_rate = 0;
1029  break;
1030  }
1031  return bit_rate;
1032 }
1033 
1034 #if FF_API_AVCODEC_OPEN
1035 int attribute_align_arg avcodec_open(AVCodecContext *avctx, AVCodec *codec)
1036 {
1037  return avcodec_open2(avctx, codec, NULL);
1038 }
1039 #endif
1040 
1041 int attribute_align_arg ff_codec_open2_recursive(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
1042 {
1043  int ret = 0;
1044 
1045  ff_unlock_avcodec();
1046 
1047  ret = avcodec_open2(avctx, codec, options);
1048 
1049  ff_lock_avcodec(avctx);
1050  return ret;
1051 }
1052 
1053 int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
1054 {
1055  int ret = 0;
1056  AVDictionary *tmp = NULL;
1057 
1058  if (avcodec_is_open(avctx))
1059  return 0;
1060 
1061  if ((!codec && !avctx->codec)) {
1062  av_log(avctx, AV_LOG_ERROR, "No codec provided to avcodec_open2()\n");
1063  return AVERROR(EINVAL);
1064  }
1065  if ((codec && avctx->codec && codec != avctx->codec)) {
1066  av_log(avctx, AV_LOG_ERROR, "This AVCodecContext was allocated for %s, "
1067  "but %s passed to avcodec_open2()\n", avctx->codec->name, codec->name);
1068  return AVERROR(EINVAL);
1069  }
1070  if (!codec)
1071  codec = avctx->codec;
1072 
1073  if (avctx->extradata_size < 0 || avctx->extradata_size >= FF_MAX_EXTRADATA_SIZE)
1074  return AVERROR(EINVAL);
1075 
1076  if (options)
1077  av_dict_copy(&tmp, *options, 0);
1078 
1079  ret = ff_lock_avcodec(avctx);
1080  if (ret < 0)
1081  return ret;
1082 
1083  avctx->internal = av_mallocz(sizeof(AVCodecInternal));
1084  if (!avctx->internal) {
1085  ret = AVERROR(ENOMEM);
1086  goto end;
1087  }
1088 
1089  avctx->internal->pool = av_mallocz(sizeof(*avctx->internal->pool));
1090  if (!avctx->internal->pool) {
1091  ret = AVERROR(ENOMEM);
1092  goto free_and_end;
1093  }
1094 
1095  if (codec->priv_data_size > 0) {
1096  if (!avctx->priv_data) {
1097  avctx->priv_data = av_mallocz(codec->priv_data_size);
1098  if (!avctx->priv_data) {
1099  ret = AVERROR(ENOMEM);
1100  goto end;
1101  }
1102  if (codec->priv_class) {
1103  *(const AVClass **)avctx->priv_data = codec->priv_class;
1104  av_opt_set_defaults(avctx->priv_data);
1105  }
1106  }
1107  if (codec->priv_class && (ret = av_opt_set_dict(avctx->priv_data, &tmp)) < 0)
1108  goto free_and_end;
1109  } else {
1110  avctx->priv_data = NULL;
1111  }
1112  if ((ret = av_opt_set_dict(avctx, &tmp)) < 0)
1113  goto free_and_end;
1114 
1115  // only call avcodec_set_dimensions() for non H.264/VP6F codecs so as not to overwrite previously setup dimensions
1116  if (!(avctx->coded_width && avctx->coded_height && avctx->width && avctx->height &&
1117  (avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_VP6F))) {
1118  if (avctx->coded_width && avctx->coded_height)
1119  avcodec_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);
1120  else if (avctx->width && avctx->height)
1121  avcodec_set_dimensions(avctx, avctx->width, avctx->height);
1122  }
1123 
1124  if ((avctx->coded_width || avctx->coded_height || avctx->width || avctx->height)
1125  && ( av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx) < 0
1126  || av_image_check_size(avctx->width, avctx->height, 0, avctx) < 0)) {
1127  av_log(avctx, AV_LOG_WARNING, "Ignoring invalid width/height values\n");
1128  avcodec_set_dimensions(avctx, 0, 0);
1129  }
1130 
1131  /* if the decoder init function was already called previously,
1132  * free the already allocated subtitle_header before overwriting it */
1133  if (av_codec_is_decoder(codec))
1134  av_freep(&avctx->subtitle_header);
1135 
1136  if (avctx->channels > FF_SANE_NB_CHANNELS) {
1137  ret = AVERROR(EINVAL);
1138  goto free_and_end;
1139  }
1140 
1141  avctx->codec = codec;
1142  if ((avctx->codec_type == AVMEDIA_TYPE_UNKNOWN || avctx->codec_type == codec->type) &&
1143  avctx->codec_id == AV_CODEC_ID_NONE) {
1144  avctx->codec_type = codec->type;
1145  avctx->codec_id = codec->id;
1146  }
1147  if (avctx->codec_id != codec->id || (avctx->codec_type != codec->type
1148  && avctx->codec_type != AVMEDIA_TYPE_ATTACHMENT)) {
1149  av_log(avctx, AV_LOG_ERROR, "Codec type or id mismatches\n");
1150  ret = AVERROR(EINVAL);
1151  goto free_and_end;
1152  }
1153  avctx->frame_number = 0;
1154  avctx->codec_descriptor = avcodec_descriptor_get(avctx->codec_id);
1155 
1156  if (avctx->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
1157  avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
1158  const char *codec_string = av_codec_is_encoder(codec) ? "encoder" : "decoder";
1159  AVCodec *codec2;
1160  av_log(avctx, AV_LOG_ERROR,
1161  "The %s '%s' is experimental but experimental codecs are not enabled, "
1162  "add '-strict %d' if you want to use it.\n",
1163  codec_string, codec->name, FF_COMPLIANCE_EXPERIMENTAL);
1164  codec2 = av_codec_is_encoder(codec) ? avcodec_find_encoder(codec->id) : avcodec_find_decoder(codec->id);
1165  if (!(codec2->capabilities & CODEC_CAP_EXPERIMENTAL))
1166  av_log(avctx, AV_LOG_ERROR, "Alternatively use the non experimental %s '%s'.\n",
1167  codec_string, codec2->name);
1168  ret = AVERROR_EXPERIMENTAL;
1169  goto free_and_end;
1170  }
1171 
1172  if (avctx->codec_type == AVMEDIA_TYPE_AUDIO &&
1173  (!avctx->time_base.num || !avctx->time_base.den)) {
1174  avctx->time_base.num = 1;
1175  avctx->time_base.den = avctx->sample_rate;
1176  }
1177 
1178  if (!HAVE_THREADS)
1179  av_log(avctx, AV_LOG_WARNING, "Warning: not compiled with thread support, using thread emulation\n");
1180 
1181  if (CONFIG_FRAME_THREAD_ENCODER) {
1182  ff_unlock_avcodec(); //we will instanciate a few encoders thus kick the counter to prevent false detection of a problem
1183  ret = ff_frame_thread_encoder_init(avctx, options ? *options : NULL);
1184  ff_lock_avcodec(avctx);
1185  if (ret < 0)
1186  goto free_and_end;
1187  }
1188 
1189  if (HAVE_THREADS
1190  && !(avctx->internal->frame_thread_encoder && (avctx->active_thread_type&FF_THREAD_FRAME))) {
1191  ret = ff_thread_init(avctx);
1192  if (ret < 0) {
1193  goto free_and_end;
1194  }
1195  }
1196  if (!HAVE_THREADS && !(codec->capabilities & CODEC_CAP_AUTO_THREADS))
1197  avctx->thread_count = 1;
1198 
1199  if (avctx->codec->max_lowres < avctx->lowres || avctx->lowres < 0) {
1200  av_log(avctx, AV_LOG_ERROR, "The maximum value for lowres supported by the decoder is %d\n",
1201  avctx->codec->max_lowres);
1202  ret = AVERROR(EINVAL);
1203  goto free_and_end;
1204  }
1205 
1206  if (av_codec_is_encoder(avctx->codec)) {
1207  int i;
1208  if (avctx->codec->sample_fmts) {
1209  for (i = 0; avctx->codec->sample_fmts[i] != AV_SAMPLE_FMT_NONE; i++) {
1210  if (avctx->sample_fmt == avctx->codec->sample_fmts[i])
1211  break;
1212  if (avctx->channels == 1 &&
1213  av_get_planar_sample_fmt(avctx->sample_fmt) ==
1214  av_get_planar_sample_fmt(avctx->codec->sample_fmts[i])) {
1215  avctx->sample_fmt = avctx->codec->sample_fmts[i];
1216  break;
1217  }
1218  }
1219  if (avctx->codec->sample_fmts[i] == AV_SAMPLE_FMT_NONE) {
1220  char buf[128];
1221  snprintf(buf, sizeof(buf), "%d", avctx->sample_fmt);
1222  av_log(avctx, AV_LOG_ERROR, "Specified sample format %s is invalid or not supported\n",
1223  (char *)av_x_if_null(av_get_sample_fmt_name(avctx->sample_fmt), buf));
1224  ret = AVERROR(EINVAL);
1225  goto free_and_end;
1226  }
1227  }
1228  if (avctx->codec->pix_fmts) {
1229  for (i = 0; avctx->codec->pix_fmts[i] != AV_PIX_FMT_NONE; i++)
1230  if (avctx->pix_fmt == avctx->codec->pix_fmts[i])
1231  break;
1232  if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_NONE
1233  && !((avctx->codec_id == AV_CODEC_ID_MJPEG || avctx->codec_id == AV_CODEC_ID_LJPEG)
1234  && avctx->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL)) {
1235  char buf[128];
1236  snprintf(buf, sizeof(buf), "%d", avctx->pix_fmt);
1237  av_log(avctx, AV_LOG_ERROR, "Specified pixel format %s is invalid or not supported\n",
1238  (char *)av_x_if_null(av_get_pix_fmt_name(avctx->pix_fmt), buf));
1239  ret = AVERROR(EINVAL);
1240  goto free_and_end;
1241  }
1242  }
1243  if (avctx->codec->supported_samplerates) {
1244  for (i = 0; avctx->codec->supported_samplerates[i] != 0; i++)
1245  if (avctx->sample_rate == avctx->codec->supported_samplerates[i])
1246  break;
1247  if (avctx->codec->supported_samplerates[i] == 0) {
1248  av_log(avctx, AV_LOG_ERROR, "Specified sample rate %d is not supported\n",
1249  avctx->sample_rate);
1250  ret = AVERROR(EINVAL);
1251  goto free_and_end;
1252  }
1253  }
1254  if (avctx->codec->channel_layouts) {
1255  if (!avctx->channel_layout) {
1256  av_log(avctx, AV_LOG_WARNING, "Channel layout not specified\n");
1257  } else {
1258  for (i = 0; avctx->codec->channel_layouts[i] != 0; i++)
1259  if (avctx->channel_layout == avctx->codec->channel_layouts[i])
1260  break;
1261  if (avctx->codec->channel_layouts[i] == 0) {
1262  char buf[512];
1263  av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
1264  av_log(avctx, AV_LOG_ERROR, "Specified channel layout '%s' is not supported\n", buf);
1265  ret = AVERROR(EINVAL);
1266  goto free_and_end;
1267  }
1268  }
1269  }
1270  if (avctx->channel_layout && avctx->channels) {
1271  int channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
1272  if (channels != avctx->channels) {
1273  char buf[512];
1274  av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
1275  av_log(avctx, AV_LOG_ERROR,
1276  "Channel layout '%s' with %d channels does not match number of specified channels %d\n",
1277  buf, channels, avctx->channels);
1278  ret = AVERROR(EINVAL);
1279  goto free_and_end;
1280  }
1281  } else if (avctx->channel_layout) {
1282  avctx->channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
1283  }
1284  if(avctx->codec_type == AVMEDIA_TYPE_VIDEO &&
1285  avctx->codec_id != AV_CODEC_ID_PNG // For mplayer
1286  ) {
1287  if (avctx->width <= 0 || avctx->height <= 0) {
1288  av_log(avctx, AV_LOG_ERROR, "dimensions not set\n");
1289  ret = AVERROR(EINVAL);
1290  goto free_and_end;
1291  }
1292  }
1293  if ( (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO)
1294  && avctx->bit_rate>0 && avctx->bit_rate<1000) {
1295  av_log(avctx, AV_LOG_WARNING, "Bitrate %d is extremely low, maybe you mean %dk\n", avctx->bit_rate, avctx->bit_rate);
1296  }
1297 
1298  if (!avctx->rc_initial_buffer_occupancy)
1299  avctx->rc_initial_buffer_occupancy = avctx->rc_buffer_size * 3 / 4;
1300  }
1301 
1302  avctx->pts_correction_num_faulty_pts =
1303  avctx->pts_correction_num_faulty_dts = 0;
1304  avctx->pts_correction_last_pts =
1305  avctx->pts_correction_last_dts = INT64_MIN;
1306 
1307  if ( avctx->codec->init && (!(avctx->active_thread_type&FF_THREAD_FRAME)
1308  || avctx->internal->frame_thread_encoder)) {
1309  ret = avctx->codec->init(avctx);
1310  if (ret < 0) {
1311  goto free_and_end;
1312  }
1313  }
1314 
1315  ret=0;
1316 
1317  if (av_codec_is_decoder(avctx->codec)) {
1318  if (!avctx->bit_rate)
1319  avctx->bit_rate = get_bit_rate(avctx);
1320  /* validate channel layout from the decoder */
1321  if (avctx->channel_layout) {
1322  int channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
1323  if (!avctx->channels)
1324  avctx->channels = channels;
1325  else if (channels != avctx->channels) {
1326  char buf[512];
1327  av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
1328  av_log(avctx, AV_LOG_WARNING,
1329  "Channel layout '%s' with %d channels does not match specified number of channels %d: "
1330  "ignoring specified channel layout\n",
1331  buf, channels, avctx->channels);
1332  avctx->channel_layout = 0;
1333  }
1334  }
1335  if (avctx->channels && avctx->channels < 0 ||
1336  avctx->channels > FF_SANE_NB_CHANNELS) {
1337  ret = AVERROR(EINVAL);
1338  goto free_and_end;
1339  }
1340  if (avctx->sub_charenc) {
1341  if (avctx->codec_type != AVMEDIA_TYPE_SUBTITLE) {
1342  av_log(avctx, AV_LOG_ERROR, "Character encoding is only "
1343  "supported with subtitles codecs\n");
1344  ret = AVERROR(EINVAL);
1345  goto free_and_end;
1346  } else if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB) {
1347  av_log(avctx, AV_LOG_WARNING, "Codec '%s' is bitmap-based, "
1348  "subtitles character encoding will be ignored\n",
1349  avctx->codec_descriptor->name);
1350  avctx->sub_charenc_mode = FF_SUB_CHARENC_MODE_DO_NOTHING;
1351  } else {
1352  /* input character encoding is set for a text based subtitle
1353  * codec at this point */
1354  if (avctx->sub_charenc_mode == FF_SUB_CHARENC_MODE_AUTOMATIC)
1355  avctx->sub_charenc_mode = FF_SUB_CHARENC_MODE_PRE_DECODER;
1356 
1357  if (avctx->sub_charenc_mode == FF_SUB_CHARENC_MODE_PRE_DECODER) {
1358 #if CONFIG_ICONV
1359  iconv_t cd = iconv_open("UTF-8", avctx->sub_charenc);
1360  if (cd == (iconv_t)-1) {
1361  av_log(avctx, AV_LOG_ERROR, "Unable to open iconv context "
1362  "with input character encoding \"%s\"\n", avctx->sub_charenc);
1363  ret = AVERROR(errno);
1364  goto free_and_end;
1365  }
1366  iconv_close(cd);
1367 #else
1368  av_log(avctx, AV_LOG_ERROR, "Character encoding subtitles "
1369  "conversion needs a libavcodec built with iconv support "
1370  "for this codec\n");
1371  ret = AVERROR(ENOSYS);
1372  goto free_and_end;
1373 #endif
1374  }
1375  }
1376  }
1377  }
1378 end:
1379  ff_unlock_avcodec();
1380  if (options) {
1381  av_dict_free(options);
1382  *options = tmp;
1383  }
1384 
1385  return ret;
1386 free_and_end:
1387  av_dict_free(&tmp);
1388  av_freep(&avctx->priv_data);
1389  if (avctx->internal)
1390  av_freep(&avctx->internal->pool);
1391  av_freep(&avctx->internal);
1392  avctx->codec = NULL;
1393  goto end;
1394 }
1395 
1396 int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int size)
1397 {
1398  if (size < 0 || avpkt->size < 0 || size > INT_MAX - FF_INPUT_BUFFER_PADDING_SIZE) {
1399  av_log(avctx, AV_LOG_ERROR, "Size %d invalid\n", size);
1400  return AVERROR(EINVAL);
1401  }
1402 
1403  if (avctx) {
1404  av_assert0(!avpkt->data || avpkt->data != avctx->internal->byte_buffer);
1405  if (!avpkt->data || avpkt->size < size) {
1406  av_fast_padded_malloc(&avctx->internal->byte_buffer, &avctx->internal->byte_buffer_size, size);
1407  avpkt->data = avctx->internal->byte_buffer;
1408  avpkt->size = avctx->internal->byte_buffer_size;
1409  avpkt->destruct = NULL;
1410  }
1411  }
1412 
1413  if (avpkt->data) {
1414  AVBufferRef *buf = avpkt->buf;
1415 #if FF_API_DESTRUCT_PACKET
1416  void *destruct = avpkt->destruct;
1417 #endif
1418 
1419  if (avpkt->size < size) {
1420  av_log(avctx, AV_LOG_ERROR, "User packet is too small (%d < %d)\n", avpkt->size, size);
1421  return AVERROR(EINVAL);
1422  }
1423 
1424  av_init_packet(avpkt);
1425 #if FF_API_DESTRUCT_PACKET
1426  avpkt->destruct = destruct;
1427 #endif
1428  avpkt->buf = buf;
1429  avpkt->size = size;
1430  return 0;
1431  } else {
1432  int ret = av_new_packet(avpkt, size);
1433  if (ret < 0)
1434  av_log(avctx, AV_LOG_ERROR, "Failed to allocate packet of size %d\n", size);
1435  return ret;
1436  }
1437 }
1438 
1439 int ff_alloc_packet(AVPacket *avpkt, int size)
1440 {
1441  return ff_alloc_packet2(NULL, avpkt, size);
1442 }
1443 
1444 /**
1445  * Pad last frame with silence.
1446  */
1447 static int pad_last_frame(AVCodecContext *s, AVFrame **dst, const AVFrame *src)
1448 {
1449  AVFrame *frame = NULL;
1450  uint8_t *buf = NULL;
1451  int ret;
1452 
1453  if (!(frame = avcodec_alloc_frame()))
1454  return AVERROR(ENOMEM);
1455  *frame = *src;
1456 
1457  if ((ret = av_samples_get_buffer_size(&frame->linesize[0], s->channels,
1458  s->frame_size, s->sample_fmt, 0)) < 0)
1459  goto fail;
1460 
1461  if (!(buf = av_malloc(ret))) {
1462  ret = AVERROR(ENOMEM);
1463  goto fail;
1464  }
1465 
1466  frame->nb_samples = s->frame_size;
1467  if ((ret = avcodec_fill_audio_frame(frame, s->channels, s->sample_fmt,
1468  buf, ret, 0)) < 0)
1469  goto fail;
1470  if ((ret = av_samples_copy(frame->extended_data, src->extended_data, 0, 0,
1471  src->nb_samples, s->channels, s->sample_fmt)) < 0)
1472  goto fail;
1473  if ((ret = av_samples_set_silence(frame->extended_data, src->nb_samples,
1474  frame->nb_samples - src->nb_samples,
1475  s->channels, s->sample_fmt)) < 0)
1476  goto fail;
1477 
1478  *dst = frame;
1479 
1480  return 0;
1481 
1482 fail:
1483  if (frame->extended_data != frame->data)
1484  av_freep(&frame->extended_data);
1485  av_freep(&buf);
1486  av_freep(&frame);
1487  return ret;
1488 }
1489 
1490 int attribute_align_arg avcodec_encode_audio2(AVCodecContext *avctx,
1491  AVPacket *avpkt,
1492  const AVFrame *frame,
1493  int *got_packet_ptr)
1494 {
1495  AVFrame tmp;
1496  AVFrame *padded_frame = NULL;
1497  int ret;
1498  AVPacket user_pkt = *avpkt;
1499  int needs_realloc = !user_pkt.data;
1500 
1501  *got_packet_ptr = 0;
1502 
1503  if (!(avctx->codec->capabilities & CODEC_CAP_DELAY) && !frame) {
1504  av_free_packet(avpkt);
1505  av_init_packet(avpkt);
1506  return 0;
1507  }
1508 
1509  /* ensure that extended_data is properly set */
1510  if (frame && !frame->extended_data) {
1511  if (av_sample_fmt_is_planar(avctx->sample_fmt) &&
1512  avctx->channels > AV_NUM_DATA_POINTERS) {
1513  av_log(avctx, AV_LOG_ERROR, "Encoding to a planar sample format, "
1514  "with more than %d channels, but extended_data is not set.\n",
1515  AV_NUM_DATA_POINTERS);
1516  return AVERROR(EINVAL);
1517  }
1518  av_log(avctx, AV_LOG_WARNING, "extended_data is not set.\n");
1519 
1520  tmp = *frame;
1521  tmp.extended_data = tmp.data;
1522  frame = &tmp;
1523  }
1524 
1525  /* check for valid frame size */
1526  if (frame) {
1527  if (avctx->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1528  if (frame->nb_samples > avctx->frame_size) {
1529  av_log(avctx, AV_LOG_ERROR, "more samples than frame size (avcodec_encode_audio2)\n");
1530  return AVERROR(EINVAL);
1531  }
1532  } else if (!(avctx->codec->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE)) {
1533  if (frame->nb_samples < avctx->frame_size &&
1534  !avctx->internal->last_audio_frame) {
1535  ret = pad_last_frame(avctx, &padded_frame, frame);
1536  if (ret < 0)
1537  return ret;
1538 
1539  frame = padded_frame;
1540  avctx->internal->last_audio_frame = 1;
1541  }
1542 
1543  if (frame->nb_samples != avctx->frame_size) {
1544  av_log(avctx, AV_LOG_ERROR, "nb_samples (%d) != frame_size (%d) (avcodec_encode_audio2)\n", frame->nb_samples, avctx->frame_size);
1545  ret = AVERROR(EINVAL);
1546  goto end;
1547  }
1548  }
1549  }
1550 
1551  ret = avctx->codec->encode2(avctx, avpkt, frame, got_packet_ptr);
1552  if (!ret) {
1553  if (*got_packet_ptr) {
1554  if (!(avctx->codec->capabilities & CODEC_CAP_DELAY)) {
1555  if (avpkt->pts == AV_NOPTS_VALUE)
1556  avpkt->pts = frame->pts;
1557  if (!avpkt->duration)
1558  avpkt->duration = ff_samples_to_time_base(avctx,
1559  frame->nb_samples);
1560  }
1561  avpkt->dts = avpkt->pts;
1562  } else {
1563  avpkt->size = 0;
1564  }
1565  }
1566  if (avpkt->data && avpkt->data == avctx->internal->byte_buffer) {
1567  needs_realloc = 0;
1568  if (user_pkt.data) {
1569  if (user_pkt.size >= avpkt->size) {
1570  memcpy(user_pkt.data, avpkt->data, avpkt->size);
1571  } else {
1572  av_log(avctx, AV_LOG_ERROR, "Provided packet is too small, needs to be %d\n", avpkt->size);
1573  avpkt->size = user_pkt.size;
1574  ret = -1;
1575  }
1576  avpkt->buf = user_pkt.buf;
1577  avpkt->data = user_pkt.data;
1578  avpkt->destruct = user_pkt.destruct;
1579  } else {
1580  if (av_dup_packet(avpkt) < 0) {
1581  ret = AVERROR(ENOMEM);
1582  }
1583  }
1584  }
1585 
1586  if (!ret) {
1587  if (needs_realloc && avpkt->data) {
1588  ret = av_buffer_realloc(&avpkt->buf, avpkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
1589  if (ret >= 0)
1590  avpkt->data = avpkt->buf->data;
1591  }
1592 
1593  avctx->frame_number++;
1594  }
1595 
1596  if (ret < 0 || !*got_packet_ptr) {
1597  av_free_packet(avpkt);
1598  av_init_packet(avpkt);
1599  goto end;
1600  }
1601 
1602  /* NOTE: if we add any audio encoders which output non-keyframe packets,
1603  * this needs to be moved to the encoders, but for now we can do it
1604  * here to simplify things */
1605  avpkt->flags |= AV_PKT_FLAG_KEY;
1606 
1607 end:
1608  if (padded_frame) {
1609  av_freep(&padded_frame->data[0]);
1610  if (padded_frame->extended_data != padded_frame->data)
1611  av_freep(&padded_frame->extended_data);
1612  av_freep(&padded_frame);
1613  }
1614 
1615  return ret;
1616 }
1617 
1618 #if FF_API_OLD_ENCODE_AUDIO
1619 int attribute_align_arg avcodec_encode_audio(AVCodecContext *avctx,
1620  uint8_t *buf, int buf_size,
1621  const short *samples)
1622 {
1623  AVPacket pkt;
1624  AVFrame frame0 = { { 0 } };
1625  AVFrame *frame;
1626  int ret, samples_size, got_packet;
1627 
1628  av_init_packet(&pkt);
1629  pkt.data = buf;
1630  pkt.size = buf_size;
1631 
1632  if (samples) {
1633  frame = &frame0;
1634  avcodec_get_frame_defaults(frame);
1635 
1636  if (avctx->frame_size) {
1637  frame->nb_samples = avctx->frame_size;
1638  } else {
1639  /* if frame_size is not set, the number of samples must be
1640  * calculated from the buffer size */
1641  int64_t nb_samples;
1642  if (!av_get_bits_per_sample(avctx->codec_id)) {
1643  av_log(avctx, AV_LOG_ERROR, "avcodec_encode_audio() does not "
1644  "support this codec\n");
1645  return AVERROR(EINVAL);
1646  }
1647  nb_samples = (int64_t)buf_size * 8 /
1648  (av_get_bits_per_sample(avctx->codec_id) *
1649  avctx->channels);
1650  if (nb_samples >= INT_MAX)
1651  return AVERROR(EINVAL);
1652  frame->nb_samples = nb_samples;
1653  }
1654 
1655  /* it is assumed that the samples buffer is large enough based on the
1656  * relevant parameters */
1657  samples_size = av_samples_get_buffer_size(NULL, avctx->channels,
1658  frame->nb_samples,
1659  avctx->sample_fmt, 1);
1660  if ((ret = avcodec_fill_audio_frame(frame, avctx->channels,
1661  avctx->sample_fmt,
1662  (const uint8_t *)samples,
1663  samples_size, 1)) < 0)
1664  return ret;
1665 
1666  /* fabricate frame pts from sample count.
1667  * this is needed because the avcodec_encode_audio() API does not have
1668  * a way for the user to provide pts */
1669  if (avctx->sample_rate && avctx->time_base.num)
1670  frame->pts = ff_samples_to_time_base(avctx,
1671  avctx->internal->sample_count);
1672  else
1673  frame->pts = AV_NOPTS_VALUE;
1674  avctx->internal->sample_count += frame->nb_samples;
1675  } else {
1676  frame = NULL;
1677  }
1678 
1679  got_packet = 0;
1680  ret = avcodec_encode_audio2(avctx, &pkt, frame, &got_packet);
1681  if (!ret && got_packet && avctx->coded_frame) {
1682  avctx->coded_frame->pts = pkt.pts;
1683  avctx->coded_frame->key_frame = !!(pkt.flags & AV_PKT_FLAG_KEY);
1684  }
1685  /* free any side data since we cannot return it */
1686  ff_packet_free_side_data(&pkt);
1687 
1688  if (frame && frame->extended_data != frame->data)
1689  av_freep(&frame->extended_data);
1690 
1691  return ret ? ret : pkt.size;
1692 }
1693 
1694 #endif
1695 
1696 #if FF_API_OLD_ENCODE_VIDEO
1697 int attribute_align_arg avcodec_encode_video(AVCodecContext *avctx, uint8_t *buf, int buf_size,
1698  const AVFrame *pict)
1699 {
1700  AVPacket pkt;
1701  int ret, got_packet = 0;
1702 
1703  if (buf_size < FF_MIN_BUFFER_SIZE) {
1704  av_log(avctx, AV_LOG_ERROR, "buffer smaller than minimum size\n");
1705  return -1;
1706  }
1707 
1708  av_init_packet(&pkt);
1709  pkt.data = buf;
1710  pkt.size = buf_size;
1711 
1712  ret = avcodec_encode_video2(avctx, &pkt, pict, &got_packet);
1713  if (!ret && got_packet && avctx->coded_frame) {
1714  avctx->coded_frame->pts = pkt.pts;
1715  avctx->coded_frame->key_frame = !!(pkt.flags & AV_PKT_FLAG_KEY);
1716  }
1717 
1718  /* free any side data since we cannot return it */
1719  if (pkt.side_data_elems > 0) {
1720  int i;
1721  for (i = 0; i < pkt.side_data_elems; i++)
1722  av_free(pkt.side_data[i].data);
1723  av_freep(&pkt.side_data);
1724  pkt.side_data_elems = 0;
1725  }
1726 
1727  return ret ? ret : pkt.size;
1728 }
1729 
1730 #endif
1731 
1732 int attribute_align_arg avcodec_encode_video2(AVCodecContext *avctx,
1733  AVPacket *avpkt,
1734  const AVFrame *frame,
1735  int *got_packet_ptr)
1736 {
1737  int ret;
1738  AVPacket user_pkt = *avpkt;
1739  int needs_realloc = !user_pkt.data;
1740 
1741  *got_packet_ptr = 0;
1742 
1743  if(CONFIG_FRAME_THREAD_ENCODER &&
1744  avctx->internal->frame_thread_encoder && (avctx->active_thread_type&FF_THREAD_FRAME))
1745  return ff_thread_video_encode_frame(avctx, avpkt, frame, got_packet_ptr);
1746 
1747  if ((avctx->flags&CODEC_FLAG_PASS1) && avctx->stats_out)
1748  avctx->stats_out[0] = '\0';
1749 
1750  if (!(avctx->codec->capabilities & CODEC_CAP_DELAY) && !frame) {
1751  av_free_packet(avpkt);
1752  av_init_packet(avpkt);
1753  avpkt->size = 0;
1754  return 0;
1755  }
1756 
1757  if (av_image_check_size(avctx->width, avctx->height, 0, avctx))
1758  return AVERROR(EINVAL);
1759 
1760  av_assert0(avctx->codec->encode2);
1761 
1762  ret = avctx->codec->encode2(avctx, avpkt, frame, got_packet_ptr);
1763  av_assert0(ret <= 0);
1764 
1765  if (avpkt->data && avpkt->data == avctx->internal->byte_buffer) {
1766  needs_realloc = 0;
1767  if (user_pkt.data) {
1768  if (user_pkt.size >= avpkt->size) {
1769  memcpy(user_pkt.data, avpkt->data, avpkt->size);
1770  } else {
1771  av_log(avctx, AV_LOG_ERROR, "Provided packet is too small, needs to be %d\n", avpkt->size);
1772  avpkt->size = user_pkt.size;
1773  ret = -1;
1774  }
1775  avpkt->buf = user_pkt.buf;
1776  avpkt->data = user_pkt.data;
1777  avpkt->destruct = user_pkt.destruct;
1778  } else {
1779  if (av_dup_packet(avpkt) < 0) {
1780  ret = AVERROR(ENOMEM);
1781  }
1782  }
1783  }
1784 
1785  if (!ret) {
1786  if (!*got_packet_ptr)
1787  avpkt->size = 0;
1788  else if (!(avctx->codec->capabilities & CODEC_CAP_DELAY))
1789  avpkt->pts = avpkt->dts = frame->pts;
1790 
1791  if (needs_realloc && avpkt->data) {
1792  ret = av_buffer_realloc(&avpkt->buf, avpkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
1793  if (ret >= 0)
1794  avpkt->data = avpkt->buf->data;
1795  }
1796 
1797  avctx->frame_number++;
1798  }
1799 
1800  if (ret < 0 || !*got_packet_ptr)
1801  av_free_packet(avpkt);
1802  else
1803  av_packet_merge_side_data(avpkt);
1804 
1805  emms_c();
1806  return ret;
1807 }
1808 
1809 int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size,
1810  const AVSubtitle *sub)
1811 {
1812  int ret;
1813  if (sub->start_display_time) {
1814  av_log(avctx, AV_LOG_ERROR, "start_display_time must be 0.\n");
1815  return -1;
1816  }
1817 
1818  ret = avctx->codec->encode_sub(avctx, buf, buf_size, sub);
1819  avctx->frame_number++;
1820  return ret;
1821 }
1822 
1823 /**
1824  * Attempt to guess proper monotonic timestamps for decoded video frames
1825  * which might have incorrect times. Input timestamps may wrap around, in
1826  * which case the output will as well.
1827  *
1828  * @param pts the pts field of the decoded AVPacket, as passed through
1829  * AVFrame.pkt_pts
1830  * @param dts the dts field of the decoded AVPacket
1831  * @return one of the input values, may be AV_NOPTS_VALUE
1832  */
1833 static int64_t guess_correct_pts(AVCodecContext *ctx,
1834  int64_t reordered_pts, int64_t dts)
1835 {
1836  int64_t pts = AV_NOPTS_VALUE;
1837 
1838  if (dts != AV_NOPTS_VALUE) {
1839  ctx->pts_correction_num_faulty_dts += dts <= ctx->pts_correction_last_dts;
1840  ctx->pts_correction_last_dts = dts;
1841  }
1842  if (reordered_pts != AV_NOPTS_VALUE) {
1843  ctx->pts_correction_num_faulty_pts += reordered_pts <= ctx->pts_correction_last_pts;
1844  ctx->pts_correction_last_pts = reordered_pts;
1845  }
1846  if ((ctx->pts_correction_num_faulty_pts<=ctx->pts_correction_num_faulty_dts || dts == AV_NOPTS_VALUE)
1847  && reordered_pts != AV_NOPTS_VALUE)
1848  pts = reordered_pts;
1849  else
1850  pts = dts;
1851 
1852  return pts;
1853 }
1854 
1855 static void apply_param_change(AVCodecContext *avctx, AVPacket *avpkt)
1856 {
1857  int size = 0;
1858  const uint8_t *data;
1859  uint32_t flags;
1860 
1861  if (!(avctx->codec->capabilities & CODEC_CAP_PARAM_CHANGE))
1862  return;
1863 
1864  data = av_packet_get_side_data(avpkt, AV_PKT_DATA_PARAM_CHANGE, &size);
1865  if (!data || size < 4)
1866  return;
1867  flags = bytestream_get_le32(&data);
1868  size -= 4;
1869  if (size < 4) /* Required for any of the changes */
1870  return;
1871  if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT) {
1872  avctx->channels = bytestream_get_le32(&data);
1873  size -= 4;
1874  }
1875  if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT) {
1876  if (size < 8)
1877  return;
1878  avctx->channel_layout = bytestream_get_le64(&data);
1879  size -= 8;
1880  }
1881  if (size < 4)
1882  return;
1883  if (flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE) {
1884  avctx->sample_rate = bytestream_get_le32(&data);
1885  size -= 4;
1886  }
1887  if (flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS) {
1888  if (size < 8)
1889  return;
1890  avctx->width = bytestream_get_le32(&data);
1891  avctx->height = bytestream_get_le32(&data);
1892  avcodec_set_dimensions(avctx, avctx->width, avctx->height);
1893  size -= 8;
1894  }
1895 }
1896 
1897 static int add_metadata_from_side_data(AVCodecContext *avctx, AVFrame *frame)
1898 {
1899  int size, ret = 0;
1900  const uint8_t *side_metadata;
1901  const uint8_t *end;
1902 
1903  side_metadata = av_packet_get_side_data(avctx->pkt,
1904  AV_PKT_DATA_STRINGS_METADATA, &size);
1905  if (!side_metadata)
1906  goto end;
1907  end = side_metadata + size;
1908  while (side_metadata < end) {
1909  const uint8_t *key = side_metadata;
1910  const uint8_t *val = side_metadata + strlen(key) + 1;
1911  int ret = av_dict_set(avpriv_frame_get_metadatap(frame), key, val, 0);
1912  if (ret < 0)
1913  break;
1914  side_metadata = val + strlen(val) + 1;
1915  }
1916 end:
1917  return ret;
1918 }
1919 
1920 int attribute_align_arg avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
1921  int *got_picture_ptr,
1922  const AVPacket *avpkt)
1923 {
1924  AVCodecInternal *avci = avctx->internal;
1925  int ret;
1926  // copy to ensure we do not change avpkt
1927  AVPacket tmp = *avpkt;
1928 
1929  if (avctx->codec->type != AVMEDIA_TYPE_VIDEO) {
1930  av_log(avctx, AV_LOG_ERROR, "Invalid media type for video\n");
1931  return AVERROR(EINVAL);
1932  }
1933 
1934  *got_picture_ptr = 0;
1935  if ((avctx->coded_width || avctx->coded_height) && av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx))
1936  return AVERROR(EINVAL);
1937 
1938  avcodec_get_frame_defaults(picture);
1939 
1940  if (!avctx->refcounted_frames)
1941  av_frame_unref(&avci->to_free);
1942 
1943  if ((avctx->codec->capabilities & CODEC_CAP_DELAY) || avpkt->size || (avctx->active_thread_type & FF_THREAD_FRAME)) {
1944  int did_split = av_packet_split_side_data(&tmp);
1945  apply_param_change(avctx, &tmp);
1946  avctx->pkt = &tmp;
1947  if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME)
1948  ret = ff_thread_decode_frame(avctx, picture, got_picture_ptr,
1949  &tmp);
1950  else {
1951  ret = avctx->codec->decode(avctx, picture, got_picture_ptr,
1952  &tmp);
1953  picture->pkt_dts = avpkt->dts;
1954 
1955  if(!avctx->has_b_frames){
1956  av_frame_set_pkt_pos(picture, avpkt->pos);
1957  }
1958  //FIXME these should be under if(!avctx->has_b_frames)
1959  /* get_buffer is supposed to set frame parameters */
1960  if (!(avctx->codec->capabilities & CODEC_CAP_DR1)) {
1961  if (!picture->sample_aspect_ratio.num) picture->sample_aspect_ratio = avctx->sample_aspect_ratio;
1962  if (!picture->width) picture->width = avctx->width;
1963  if (!picture->height) picture->height = avctx->height;
1964  if (picture->format == AV_PIX_FMT_NONE) picture->format = avctx->pix_fmt;
1965  }
1966  }
1967  add_metadata_from_side_data(avctx, picture);
1968 
1969  emms_c(); //needed to avoid an emms_c() call before every return;
1970 
1971  avctx->pkt = NULL;
1972  if (did_split) {
1973  ff_packet_free_side_data(&tmp);
1974  if(ret == tmp.size)
1975  ret = avpkt->size;
1976  }
1977 
1978  if (ret < 0 && picture->data[0])
1979  av_frame_unref(picture);
1980 
1981  if (*got_picture_ptr) {
1982  if (!avctx->refcounted_frames) {
1983  avci->to_free = *picture;
1984  avci->to_free.extended_data = avci->to_free.data;
1985  memset(picture->buf, 0, sizeof(picture->buf));
1986  }
1987 
1988  avctx->frame_number++;
1989  av_frame_set_best_effort_timestamp(picture,
1990  guess_correct_pts(avctx,
1991  picture->pkt_pts,
1992  picture->pkt_dts));
1993  }
1994  } else
1995  ret = 0;
1996 
1997  /* many decoders assign whole AVFrames, thus overwriting extended_data;
1998  * make sure it's set correctly */
1999  picture->extended_data = picture->data;
2000 
2001  return ret;
2002 }
2003 
2004 #if FF_API_OLD_DECODE_AUDIO
2005 int attribute_align_arg avcodec_decode_audio3(AVCodecContext *avctx, int16_t *samples,
2006  int *frame_size_ptr,
2007  AVPacket *avpkt)
2008 {
2009  AVFrame frame = { { 0 } };
2010  int ret, got_frame = 0;
2011 
2012  if (avctx->get_buffer != avcodec_default_get_buffer) {
2013  av_log(avctx, AV_LOG_ERROR, "Custom get_buffer() for use with"
2014  "avcodec_decode_audio3() detected. Overriding with avcodec_default_get_buffer\n");
2015  av_log(avctx, AV_LOG_ERROR, "Please port your application to "
2016  "avcodec_decode_audio4()\n");
2017  avctx->get_buffer = avcodec_default_get_buffer;
2018  avctx->release_buffer = avcodec_default_release_buffer;
2019  }
2020 
2021  ret = avcodec_decode_audio4(avctx, &frame, &got_frame, avpkt);
2022 
2023  if (ret >= 0 && got_frame) {
2024  int ch, plane_size;
2025  int planar = av_sample_fmt_is_planar(avctx->sample_fmt);
2026  int data_size = av_samples_get_buffer_size(&plane_size, avctx->channels,
2027  frame.nb_samples,
2028  avctx->sample_fmt, 1);
2029  if (*frame_size_ptr < data_size) {
2030  av_log(avctx, AV_LOG_ERROR, "output buffer size is too small for "
2031  "the current frame (%d < %d)\n", *frame_size_ptr, data_size);
2032  return AVERROR(EINVAL);
2033  }
2034 
2035  memcpy(samples, frame.extended_data[0], plane_size);
2036 
2037  if (planar && avctx->channels > 1) {
2038  uint8_t *out = ((uint8_t *)samples) + plane_size;
2039  for (ch = 1; ch < avctx->channels; ch++) {
2040  memcpy(out, frame.extended_data[ch], plane_size);
2041  out += plane_size;
2042  }
2043  }
2044  *frame_size_ptr = data_size;
2045  } else {
2046  *frame_size_ptr = 0;
2047  }
2048  return ret;
2049 }
2050 
2051 #endif
2052 
2053 int attribute_align_arg avcodec_decode_audio4(AVCodecContext *avctx,
2054  AVFrame *frame,
2055  int *got_frame_ptr,
2056  const AVPacket *avpkt)
2057 {
2058  AVCodecInternal *avci = avctx->internal;
2059  int planar, channels;
2060  int ret = 0;
2061 
2062  *got_frame_ptr = 0;
2063 
2064  if (!avpkt->data && avpkt->size) {
2065  av_log(avctx, AV_LOG_ERROR, "invalid packet: NULL data, size != 0\n");
2066  return AVERROR(EINVAL);
2067  }
2068  if (avctx->codec->type != AVMEDIA_TYPE_AUDIO) {
2069  av_log(avctx, AV_LOG_ERROR, "Invalid media type for audio\n");
2070  return AVERROR(EINVAL);
2071  }
2072 
2073  avcodec_get_frame_defaults(frame);
2074 
2075  if (!avctx->refcounted_frames)
2076  av_frame_unref(&avci->to_free);
2077 
2078  if ((avctx->codec->capabilities & CODEC_CAP_DELAY) || avpkt->size) {
2079  uint8_t *side;
2080  int side_size;
2081  // copy to ensure we do not change avpkt
2082  AVPacket tmp = *avpkt;
2083  int did_split = av_packet_split_side_data(&tmp);
2084  apply_param_change(avctx, &tmp);
2085 
2086  avctx->pkt = &tmp;
2087  ret = avctx->codec->decode(avctx, frame, got_frame_ptr, &tmp);
2088  if (ret >= 0 && *got_frame_ptr) {
2089  add_metadata_from_side_data(avctx, frame);
2090  avctx->frame_number++;
2091  frame->pkt_dts = avpkt->dts;
2092  av_frame_set_best_effort_timestamp(frame,
2093  guess_correct_pts(avctx,
2094  frame->pkt_pts,
2095  frame->pkt_dts));
2096  if (frame->format == AV_SAMPLE_FMT_NONE)
2097  frame->format = avctx->sample_fmt;
2098  if (!frame->channel_layout)
2099  frame->channel_layout = avctx->channel_layout;
2100  if (!av_frame_get_channels(frame))
2101  av_frame_set_channels(frame, avctx->channels);
2102  if (!frame->sample_rate)
2103  frame->sample_rate = avctx->sample_rate;
2104  }
2105 
2106  side= av_packet_get_side_data(avctx->pkt, AV_PKT_DATA_SKIP_SAMPLES, &side_size);
2107  if(side && side_size>=10) {
2108  avctx->internal->skip_samples = AV_RL32(side);
2109  av_log(avctx, AV_LOG_DEBUG, "skip %d samples due to side data\n",
2110  avctx->internal->skip_samples);
2111  }
2112  if (avctx->internal->skip_samples && *got_frame_ptr) {
2113  if(frame->nb_samples <= avctx->internal->skip_samples){
2114  *got_frame_ptr = 0;
2115  avctx->internal->skip_samples -= frame->nb_samples;
2116  av_log(avctx, AV_LOG_DEBUG, "skip whole frame, skip left: %d\n",
2117  avctx->internal->skip_samples);
2118  } else {
2119  av_samples_copy(frame->extended_data, frame->extended_data, 0, avctx->internal->skip_samples,
2120  frame->nb_samples - avctx->internal->skip_samples, avctx->channels, frame->format);
2121  if(avctx->pkt_timebase.num && avctx->sample_rate) {
2122  int64_t diff_ts = av_rescale_q(avctx->internal->skip_samples,
2123  (AVRational){1, avctx->sample_rate},
2124  avctx->pkt_timebase);
2125  if(frame->pkt_pts!=AV_NOPTS_VALUE)
2126  frame->pkt_pts += diff_ts;
2127  if(frame->pkt_dts!=AV_NOPTS_VALUE)
2128  frame->pkt_dts += diff_ts;
2129  if (av_frame_get_pkt_duration(frame) >= diff_ts)
2130  av_frame_set_pkt_duration(frame, av_frame_get_pkt_duration(frame) - diff_ts);
2131  } else {
2132  av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for skipped samples.\n");
2133  }
2134  av_log(avctx, AV_LOG_DEBUG, "skip %d/%d samples\n",
2135  avctx->internal->skip_samples, frame->nb_samples);
2136  frame->nb_samples -= avctx->internal->skip_samples;
2137  avctx->internal->skip_samples = 0;
2138  }
2139  }
2140 
2141  avctx->pkt = NULL;
2142  if (did_split) {
2143  ff_packet_free_side_data(&tmp);
2144  if(ret == tmp.size)
2145  ret = avpkt->size;
2146  }
2147 
2148  if (ret >= 0 && *got_frame_ptr) {
2149  if (!avctx->refcounted_frames) {
2150  avci->to_free = *frame;
2151  avci->to_free.extended_data = avci->to_free.data;
2152  memset(frame->buf, 0, sizeof(frame->buf));
2153  frame->extended_buf = NULL;
2154  frame->nb_extended_buf = 0;
2155  }
2156  } else if (frame->data[0])
2157  av_frame_unref(frame);
2158  }
2159 
2160  /* many decoders assign whole AVFrames, thus overwriting extended_data;
2161  * make sure it's set correctly; assume decoders that actually use
2162  * extended_data are doing it correctly */
2163  if (*got_frame_ptr) {
2164  planar = av_sample_fmt_is_planar(frame->format);
2165  channels = av_frame_get_channels(frame);
2166  if (!(planar && channels > AV_NUM_DATA_POINTERS))
2167  frame->extended_data = frame->data;
2168  } else {
2169  frame->extended_data = NULL;
2170  }
2171 
2172  return ret;
2173 }
2174 
2175 #define UTF8_MAX_BYTES 4 /* 5 and 6 bytes sequences should not be used */
2176 static int recode_subtitle(AVCodecContext *avctx,
2177  AVPacket *outpkt, const AVPacket *inpkt)
2178 {
2179 #if CONFIG_ICONV
2180  iconv_t cd = (iconv_t)-1;
2181  int ret = 0;
2182  char *inb, *outb;
2183  size_t inl, outl;
2184  AVPacket tmp;
2185 #endif
2186 
2187  if (avctx->sub_charenc_mode != FF_SUB_CHARENC_MODE_PRE_DECODER)
2188  return 0;
2189 
2190 #if CONFIG_ICONV
2191  cd = iconv_open("UTF-8", avctx->sub_charenc);
2192  av_assert0(cd != (iconv_t)-1);
2193 
2194  inb = inpkt->data;
2195  inl = inpkt->size;
2196 
2197  if (inl >= INT_MAX / UTF8_MAX_BYTES - FF_INPUT_BUFFER_PADDING_SIZE) {
2198  av_log(avctx, AV_LOG_ERROR, "Subtitles packet is too big for recoding\n");
2199  ret = AVERROR(ENOMEM);
2200  goto end;
2201  }
2202 
2203  ret = av_new_packet(&tmp, inl * UTF8_MAX_BYTES);
2204  if (ret < 0)
2205  goto end;
2206  outpkt->buf = tmp.buf;
2207  outpkt->data = tmp.data;
2208  outpkt->size = tmp.size;
2209  outb = outpkt->data;
2210  outl = outpkt->size;
2211 
2212  if (iconv(cd, &inb, &inl, &outb, &outl) == (size_t)-1 ||
2213  iconv(cd, NULL, NULL, &outb, &outl) == (size_t)-1 ||
2214  outl >= outpkt->size || inl != 0) {
2215  av_log(avctx, AV_LOG_ERROR, "Unable to recode subtitle event \"%s\" "
2216  "from %s to UTF-8\n", inpkt->data, avctx->sub_charenc);
2217  av_free_packet(&tmp);
2218  ret = AVERROR(errno);
2219  goto end;
2220  }
2221  outpkt->size -= outl;
2222  memset(outpkt->data + outpkt->size, 0, outl);
2223 
2224 end:
2225  if (cd != (iconv_t)-1)
2226  iconv_close(cd);
2227  return ret;
2228 #else
2229  av_assert0(!"requesting subtitles recoding without iconv");
2230 #endif
2231 }
2232 
2233 static int utf8_check(const uint8_t *str)
2234 {
2235  const uint8_t *byte;
2236  uint32_t codepoint, min;
2237 
2238  while (*str) {
2239  byte = str;
2240  GET_UTF8(codepoint, *(byte++), return 0;);
2241  min = byte - str == 1 ? 0 : byte - str == 2 ? 0x80 :
2242  1 << (5 * (byte - str) - 4);
2243  if (codepoint < min || codepoint >= 0x110000 ||
2244  codepoint == 0xFFFE /* BOM */ ||
2245  codepoint >= 0xD800 && codepoint <= 0xDFFF /* surrogates */)
2246  return 0;
2247  str = byte;
2248  }
2249  return 1;
2250 }
2251 
2252 int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub,
2253  int *got_sub_ptr,
2254  AVPacket *avpkt)
2255 {
2256  int i, ret = 0;
2257 
2258  if (avctx->codec->type != AVMEDIA_TYPE_SUBTITLE) {
2259  av_log(avctx, AV_LOG_ERROR, "Invalid media type for subtitles\n");
2260  return AVERROR(EINVAL);
2261  }
2262 
2263  *got_sub_ptr = 0;
2264  avcodec_get_subtitle_defaults(sub);
2265 
2266  if (avpkt->size) {
2267  AVPacket pkt_recoded;
2268  AVPacket tmp = *avpkt;
2269  int did_split = av_packet_split_side_data(&tmp);
2270  //apply_param_change(avctx, &tmp);
2271 
2272  pkt_recoded = tmp;
2273  ret = recode_subtitle(avctx, &pkt_recoded, &tmp);
2274  if (ret < 0) {
2275  *got_sub_ptr = 0;
2276  } else {
2277  avctx->pkt = &pkt_recoded;
2278 
2279  if (avctx->pkt_timebase.den && avpkt->pts != AV_NOPTS_VALUE)
2280  sub->pts = av_rescale_q(avpkt->pts,
2281  avctx->pkt_timebase, AV_TIME_BASE_Q);
2282  ret = avctx->codec->decode(avctx, sub, got_sub_ptr, &pkt_recoded);
2283  av_assert1((ret >= 0) >= !!*got_sub_ptr &&
2284  !!*got_sub_ptr >= !!sub->num_rects);
2285 
2286  if (sub->num_rects && !sub->end_display_time && avpkt->duration &&
2287  avctx->pkt_timebase.num) {
2288  AVRational ms = { 1, 1000 };
2289  sub->end_display_time = av_rescale_q(avpkt->duration,
2290  avctx->pkt_timebase, ms);
2291  }
2292 
2293  for (i = 0; i < sub->num_rects; i++) {
2294  if (sub->rects[i]->ass && !utf8_check(sub->rects[i]->ass)) {
2295  av_log(avctx, AV_LOG_ERROR,
2296  "Invalid UTF-8 in decoded subtitles text; "
2297  "maybe missing -sub_charenc option\n");
2298  avsubtitle_free(sub);
2299  return AVERROR_INVALIDDATA;
2300  }
2301  }
2302 
2303  if (tmp.data != pkt_recoded.data) { // did we recode?
2304  /* prevent from destroying side data from original packet */
2305  pkt_recoded.side_data = NULL;
2306  pkt_recoded.side_data_elems = 0;
2307 
2308  av_free_packet(&pkt_recoded);
2309  }
2310  sub->format = !(avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB);
2311  avctx->pkt = NULL;
2312  }
2313 
2314  if (did_split) {
2315  ff_packet_free_side_data(&tmp);
2316  if(ret == tmp.size)
2317  ret = avpkt->size;
2318  }
2319 
2320  if (*got_sub_ptr)
2321  avctx->frame_number++;
2322  }
2323 
2324  return ret;
2325 }
2326 
2327 void avsubtitle_free(AVSubtitle *sub)
2328 {
2329  int i;
2330 
2331  for (i = 0; i < sub->num_rects; i++) {
2332  av_freep(&sub->rects[i]->pict.data[0]);
2333  av_freep(&sub->rects[i]->pict.data[1]);
2334  av_freep(&sub->rects[i]->pict.data[2]);
2335  av_freep(&sub->rects[i]->pict.data[3]);
2336  av_freep(&sub->rects[i]->text);
2337  av_freep(&sub->rects[i]->ass);
2338  av_freep(&sub->rects[i]);
2339  }
2340 
2341  av_freep(&sub->rects);
2342 
2343  memset(sub, 0, sizeof(AVSubtitle));
2344 }
2345 
2346 av_cold int ff_codec_close_recursive(AVCodecContext *avctx)
2347 {
2348  int ret = 0;
2349 
2350  ff_unlock_avcodec();
2351 
2352  ret = avcodec_close(avctx);
2353 
2354  ff_lock_avcodec(NULL);
2355  return ret;
2356 }
2357 
2358 av_cold int avcodec_close(AVCodecContext *avctx)
2359 {
2360  int ret = ff_lock_avcodec(avctx);
2361  if (ret < 0)
2362  return ret;
2363 
2364  if (avcodec_is_open(avctx)) {
2365  FramePool *pool = avctx->internal->pool;
2366  int i;
2367  if (CONFIG_FRAME_THREAD_ENCODER &&
2368  avctx->internal->frame_thread_encoder && avctx->thread_count > 1) {
2369  ff_unlock_avcodec();
2370  ff_frame_thread_encoder_free(avctx);
2371  ff_lock_avcodec(avctx);
2372  }
2373  if (HAVE_THREADS && avctx->thread_opaque)
2374  ff_thread_free(avctx);
2375  if (avctx->codec && avctx->codec->close)
2376  avctx->codec->close(avctx);
2377  avctx->coded_frame = NULL;
2378  avctx->internal->byte_buffer_size = 0;
2379  av_freep(&avctx->internal->byte_buffer);
2380  if (!avctx->refcounted_frames)
2381  av_frame_unref(&avctx->internal->to_free);
2382  for (i = 0; i < FF_ARRAY_ELEMS(pool->pools); i++)
2383  av_buffer_pool_uninit(&pool->pools[i]);
2384  av_freep(&avctx->internal->pool);
2385  av_freep(&avctx->internal);
2386  }
2387 
2388  if (avctx->priv_data && avctx->codec && avctx->codec->priv_class)
2389  av_opt_free(avctx->priv_data);
2390  av_opt_free(avctx);
2391  av_freep(&avctx->priv_data);
2392  if (av_codec_is_encoder(avctx->codec))
2393  av_freep(&avctx->extradata);
2394  avctx->codec = NULL;
2395  avctx->active_thread_type = 0;
2396 
2397  ff_unlock_avcodec();
2398  return 0;
2399 }
2400 
2401 static enum AVCodecID remap_deprecated_codec_id(enum AVCodecID id)
2402 {
2403  switch(id){
2404  //This is for future deprecatec codec ids, its empty since
2405  //last major bump but will fill up again over time, please don't remove it
2406 // case AV_CODEC_ID_UTVIDEO_DEPRECATED: return AV_CODEC_ID_UTVIDEO;
2407  case AV_CODEC_ID_OPUS_DEPRECATED: return AV_CODEC_ID_OPUS;
2408  case AV_CODEC_ID_TAK_DEPRECATED : return AV_CODEC_ID_TAK;
2409  case AV_CODEC_ID_ESCAPE130_DEPRECATED : return AV_CODEC_ID_ESCAPE130;
2410  default : return id;
2411  }
2412 }
2413 
2414 static AVCodec *find_encdec(enum AVCodecID id, int encoder)
2415 {
2416  AVCodec *p, *experimental = NULL;
2417  p = first_avcodec;
2418  id= remap_deprecated_codec_id(id);
2419  while (p) {
2420  if ((encoder ? av_codec_is_encoder(p) : av_codec_is_decoder(p)) &&
2421  p->id == id) {
2422  if (p->capabilities & CODEC_CAP_EXPERIMENTAL && !experimental) {
2423  experimental = p;
2424  } else
2425  return p;
2426  }
2427  p = p->next;
2428  }
2429  return experimental;
2430 }
2431 
2432 AVCodec *avcodec_find_encoder(enum AVCodecID id)
2433 {
2434  return find_encdec(id, 1);
2435 }
2436 
2437 AVCodec *avcodec_find_encoder_by_name(const char *name)
2438 {
2439  AVCodec *p;
2440  if (!name)
2441  return NULL;
2442  p = first_avcodec;
2443  while (p) {
2444  if (av_codec_is_encoder(p) && strcmp(name, p->name) == 0)
2445  return p;
2446  p = p->next;
2447  }
2448  return NULL;
2449 }
2450 
2451 AVCodec *avcodec_find_decoder(enum AVCodecID id)
2452 {
2453  return find_encdec(id, 0);
2454 }
2455 
2456 AVCodec *avcodec_find_decoder_by_name(const char *name)
2457 {
2458  AVCodec *p;
2459  if (!name)
2460  return NULL;
2461  p = first_avcodec;
2462  while (p) {
2463  if (av_codec_is_decoder(p) && strcmp(name, p->name) == 0)
2464  return p;
2465  p = p->next;
2466  }
2467  return NULL;
2468 }
2469 
2470 const char *avcodec_get_name(enum AVCodecID id)
2471 {
2472  const AVCodecDescriptor *cd;
2473  AVCodec *codec;
2474 
2475  if (id == AV_CODEC_ID_NONE)
2476  return "none";
2477  cd = avcodec_descriptor_get(id);
2478  if (cd)
2479  return cd->name;
2480  av_log(NULL, AV_LOG_WARNING, "Codec 0x%x is not in the full list.\n", id);
2481  codec = avcodec_find_decoder(id);
2482  if (codec)
2483  return codec->name;
2484  codec = avcodec_find_encoder(id);
2485  if (codec)
2486  return codec->name;
2487  return "unknown_codec";
2488 }
2489 
2490 size_t av_get_codec_tag_string(char *buf, size_t buf_size, unsigned int codec_tag)
2491 {
2492  int i, len, ret = 0;
2493 
2494 #define TAG_PRINT(x) \
2495  (((x) >= '0' && (x) <= '9') || \
2496  ((x) >= 'a' && (x) <= 'z') || ((x) >= 'A' && (x) <= 'Z') || \
2497  ((x) == '.' || (x) == ' ' || (x) == '-' || (x) == '_'))
2498 
2499  for (i = 0; i < 4; i++) {
2500  len = snprintf(buf, buf_size,
2501  TAG_PRINT(codec_tag & 0xFF) ? "%c" : "[%d]", codec_tag & 0xFF);
2502  buf += len;
2503  buf_size = buf_size > len ? buf_size - len : 0;
2504  ret += len;
2505  codec_tag >>= 8;
2506  }
2507  return ret;
2508 }
2509 
2510 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
2511 {
2512  const char *codec_type;
2513  const char *codec_name;
2514  const char *profile = NULL;
2515  const AVCodec *p;
2516  int bitrate;
2517  AVRational display_aspect_ratio;
2518 
2519  if (!buf || buf_size <= 0)
2520  return;
2521  codec_type = av_get_media_type_string(enc->codec_type);
2522  codec_name = avcodec_get_name(enc->codec_id);
2523  if (enc->profile != FF_PROFILE_UNKNOWN) {
2524  if (enc->codec)
2525  p = enc->codec;
2526  else
2527  p = encode ? avcodec_find_encoder(enc->codec_id) :
2528  avcodec_find_decoder(enc->codec_id);
2529  if (p)
2530  profile = av_get_profile_name(p, enc->profile);
2531  }
2532 
2533  snprintf(buf, buf_size, "%s: %s", codec_type ? codec_type : "unknown",
2534  codec_name);
2535  buf[0] ^= 'a' ^ 'A'; /* first letter in uppercase */
2536 
2537  if (enc->codec && strcmp(enc->codec->name, codec_name))
2538  snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s)", enc->codec->name);
2539 
2540  if (profile)
2541  snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s)", profile);
2542  if (enc->codec_tag) {
2543  char tag_buf[32];
2544  av_get_codec_tag_string(tag_buf, sizeof(tag_buf), enc->codec_tag);
2545  snprintf(buf + strlen(buf), buf_size - strlen(buf),
2546  " (%s / 0x%04X)", tag_buf, enc->codec_tag);
2547  }
2548 
2549  switch (enc->codec_type) {
2550  case AVMEDIA_TYPE_VIDEO:
2551  if (enc->pix_fmt != AV_PIX_FMT_NONE) {
2552  snprintf(buf + strlen(buf), buf_size - strlen(buf),
2553  ", %s",
2554  av_get_pix_fmt_name(enc->pix_fmt));
2555  if (enc->bits_per_raw_sample &&
2556  enc->bits_per_raw_sample <= av_pix_fmt_desc_get(enc->pix_fmt)->comp[0].depth_minus1)
2557  snprintf(buf + strlen(buf), buf_size - strlen(buf),
2558  " (%d bpc)", enc->bits_per_raw_sample);
2559  }
2560  if (enc->width) {
2561  snprintf(buf + strlen(buf), buf_size - strlen(buf),
2562  ", %dx%d",
2563  enc->width, enc->height);
2564  if (enc->sample_aspect_ratio.num) {
2565  av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
2566  enc->width * enc->sample_aspect_ratio.num,
2567  enc->height * enc->sample_aspect_ratio.den,
2568  1024 * 1024);
2569  snprintf(buf + strlen(buf), buf_size - strlen(buf),
2570  " [SAR %d:%d DAR %d:%d]",
2571  enc->sample_aspect_ratio.num, enc->sample_aspect_ratio.den,
2572  display_aspect_ratio.num, display_aspect_ratio.den);
2573  }
2574  if (av_log_get_level() >= AV_LOG_DEBUG) {
2575  int g = av_gcd(enc->time_base.num, enc->time_base.den);
2576  snprintf(buf + strlen(buf), buf_size - strlen(buf),
2577  ", %d/%d",
2578  enc->time_base.num / g, enc->time_base.den / g);
2579  }
2580  }
2581  if (encode) {
2582  snprintf(buf + strlen(buf), buf_size - strlen(buf),
2583  ", q=%d-%d", enc->qmin, enc->qmax);
2584  }
2585  break;
2586  case AVMEDIA_TYPE_AUDIO:
2587  if (enc->sample_rate) {
2588  snprintf(buf + strlen(buf), buf_size - strlen(buf),
2589  ", %d Hz", enc->sample_rate);
2590  }
2591  av_strlcat(buf, ", ", buf_size);
2592  av_get_channel_layout_string(buf + strlen(buf), buf_size - strlen(buf), enc->channels, enc->channel_layout);
2593  if (enc->sample_fmt != AV_SAMPLE_FMT_NONE) {
2594  snprintf(buf + strlen(buf), buf_size - strlen(buf),
2595  ", %s", av_get_sample_fmt_name(enc->sample_fmt));
2596  }
2597  break;
2598  case AVMEDIA_TYPE_DATA:
2599  if (av_log_get_level() >= AV_LOG_DEBUG) {
2600  int g = av_gcd(enc->time_base.num, enc->time_base.den);
2601  if (g)
2602  snprintf(buf + strlen(buf), buf_size - strlen(buf),
2603  ", %d/%d",
2604  enc->time_base.num / g, enc->time_base.den / g);
2605  }
2606  break;
2607  default:
2608  return;
2609  }
2610  if (encode) {
2611  if (enc->flags & CODEC_FLAG_PASS1)
2612  snprintf(buf + strlen(buf), buf_size - strlen(buf),
2613  ", pass 1");
2614  if (enc->flags & CODEC_FLAG_PASS2)
2615  snprintf(buf + strlen(buf), buf_size - strlen(buf),
2616  ", pass 2");
2617  }
2618  bitrate = get_bit_rate(enc);
2619  if (bitrate != 0) {
2620  snprintf(buf + strlen(buf), buf_size - strlen(buf),
2621  ", %d kb/s", bitrate / 1000);
2622  }
2623 }
2624 
2625 const char *av_get_profile_name(const AVCodec *codec, int profile)
2626 {
2627  const AVProfile *p;
2628  if (profile == FF_PROFILE_UNKNOWN || !codec->profiles)
2629  return NULL;
2630 
2631  for (p = codec->profiles; p->profile != FF_PROFILE_UNKNOWN; p++)
2632  if (p->profile == profile)
2633  return p->name;
2634 
2635  return NULL;
2636 }
2637 
2638 unsigned avcodec_version(void)
2639 {
2640 // av_assert0(AV_CODEC_ID_V410==164);
2641  av_assert0(AV_CODEC_ID_PCM_S8_PLANAR==65563);
2642  av_assert0(AV_CODEC_ID_ADPCM_G722==69660);
2643 // av_assert0(AV_CODEC_ID_BMV_AUDIO==86071);
2644  av_assert0(AV_CODEC_ID_SRT==94216);
2645  av_assert0(LIBAVCODEC_VERSION_MICRO >= 100);
2646 
2647  av_assert0(CODEC_ID_CLLC == AV_CODEC_ID_CLLC);
2648  av_assert0(CODEC_ID_PCM_S8_PLANAR == AV_CODEC_ID_PCM_S8_PLANAR);
2649  av_assert0(CODEC_ID_ADPCM_IMA_APC == AV_CODEC_ID_ADPCM_IMA_APC);
2650  av_assert0(CODEC_ID_ILBC == AV_CODEC_ID_ILBC);
2651  av_assert0(CODEC_ID_SRT == AV_CODEC_ID_SRT);
2652  return LIBAVCODEC_VERSION_INT;
2653 }
2654 
2655 const char *avcodec_configuration(void)
2656 {
2657  return FFMPEG_CONFIGURATION;
2658 }
2659 
2660 const char *avcodec_license(void)
2661 {
2662 #define LICENSE_PREFIX "libavcodec license: "
2663  return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
2664 }
2665 
2666 void avcodec_flush_buffers(AVCodecContext *avctx)
2667 {
2668  if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME)
2669  ff_thread_flush(avctx);
2670  else if (avctx->codec->flush)
2671  avctx->codec->flush(avctx);
2672 
2673  avctx->pts_correction_last_pts =
2674  avctx->pts_correction_last_dts = INT64_MIN;
2675 }
2676 
2677 int av_get_exact_bits_per_sample(enum AVCodecID codec_id)
2678 {
2679  switch (codec_id) {
2680  case AV_CODEC_ID_8SVX_EXP:
2681  case AV_CODEC_ID_8SVX_FIB:
2682  case AV_CODEC_ID_ADPCM_CT:
2683  case AV_CODEC_ID_ADPCM_IMA_APC:
2684  case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
2685  case AV_CODEC_ID_ADPCM_IMA_OKI:
2686  case AV_CODEC_ID_ADPCM_IMA_WS:
2687  case AV_CODEC_ID_ADPCM_G722:
2688  case AV_CODEC_ID_ADPCM_YAMAHA:
2689  return 4;
2690  case AV_CODEC_ID_PCM_ALAW:
2691  case AV_CODEC_ID_PCM_MULAW:
2692  case AV_CODEC_ID_PCM_S8:
2693  case AV_CODEC_ID_PCM_S8_PLANAR:
2694  case AV_CODEC_ID_PCM_U8:
2695  case AV_CODEC_ID_PCM_ZORK:
2696  return 8;
2697  case AV_CODEC_ID_PCM_S16BE:
2698  case AV_CODEC_ID_PCM_S16BE_PLANAR:
2699  case AV_CODEC_ID_PCM_S16LE:
2700  case AV_CODEC_ID_PCM_S16LE_PLANAR:
2701  case AV_CODEC_ID_PCM_U16BE:
2702  case AV_CODEC_ID_PCM_U16LE:
2703  return 16;
2704  case AV_CODEC_ID_PCM_S24DAUD:
2705  case AV_CODEC_ID_PCM_S24BE:
2706  case AV_CODEC_ID_PCM_S24LE:
2707  case AV_CODEC_ID_PCM_S24LE_PLANAR:
2708  case AV_CODEC_ID_PCM_U24BE:
2709  case AV_CODEC_ID_PCM_U24LE:
2710  return 24;
2711  case AV_CODEC_ID_PCM_S32BE:
2712  case AV_CODEC_ID_PCM_S32LE:
2713  case AV_CODEC_ID_PCM_S32LE_PLANAR:
2714  case AV_CODEC_ID_PCM_U32BE:
2715  case AV_CODEC_ID_PCM_U32LE:
2716  case AV_CODEC_ID_PCM_F32BE:
2717  case AV_CODEC_ID_PCM_F32LE:
2718  return 32;
2719  case AV_CODEC_ID_PCM_F64BE:
2720  case AV_CODEC_ID_PCM_F64LE:
2721  return 64;
2722  default:
2723  return 0;
2724  }
2725 }
2726 
2727 enum AVCodecID av_get_pcm_codec(enum AVSampleFormat fmt, int be)
2728 {
2729  static const enum AVCodecID map[AV_SAMPLE_FMT_NB][2] = {
2730  [AV_SAMPLE_FMT_U8 ] = { AV_CODEC_ID_PCM_U8, AV_CODEC_ID_PCM_U8 },
2731  [AV_SAMPLE_FMT_S16 ] = { AV_CODEC_ID_PCM_S16LE, AV_CODEC_ID_PCM_S16BE },
2732  [AV_SAMPLE_FMT_S32 ] = { AV_CODEC_ID_PCM_S32LE, AV_CODEC_ID_PCM_S32BE },
2733  [AV_SAMPLE_FMT_FLT ] = { AV_CODEC_ID_PCM_F32LE, AV_CODEC_ID_PCM_F32BE },
2734  [AV_SAMPLE_FMT_DBL ] = { AV_CODEC_ID_PCM_F64LE, AV_CODEC_ID_PCM_F64BE },
2735  [AV_SAMPLE_FMT_U8P ] = { AV_CODEC_ID_PCM_U8, AV_CODEC_ID_PCM_U8 },
2736  [AV_SAMPLE_FMT_S16P] = { AV_CODEC_ID_PCM_S16LE, AV_CODEC_ID_PCM_S16BE },
2737  [AV_SAMPLE_FMT_S32P] = { AV_CODEC_ID_PCM_S32LE, AV_CODEC_ID_PCM_S32BE },
2738  [AV_SAMPLE_FMT_FLTP] = { AV_CODEC_ID_PCM_F32LE, AV_CODEC_ID_PCM_F32BE },
2739  [AV_SAMPLE_FMT_DBLP] = { AV_CODEC_ID_PCM_F64LE, AV_CODEC_ID_PCM_F64BE },
2740  };
2741  if (fmt < 0 || fmt >= AV_SAMPLE_FMT_NB)
2742  return AV_CODEC_ID_NONE;
2743  if (be < 0 || be > 1)
2744  be = AV_NE(1, 0);
2745  return map[fmt][be];
2746 }
2747 
2748 int av_get_bits_per_sample(enum AVCodecID codec_id)
2749 {
2750  switch (codec_id) {
2751  case AV_CODEC_ID_ADPCM_SBPRO_2:
2752  return 2;
2753  case AV_CODEC_ID_ADPCM_SBPRO_3:
2754  return 3;
2755  case AV_CODEC_ID_ADPCM_SBPRO_4:
2756  case AV_CODEC_ID_ADPCM_IMA_WAV:
2757  case AV_CODEC_ID_ADPCM_IMA_QT:
2758  case AV_CODEC_ID_ADPCM_SWF:
2759  case AV_CODEC_ID_ADPCM_MS:
2760  return 4;
2761  default:
2762  return av_get_exact_bits_per_sample(codec_id);
2763  }
2764 }
2765 
2766 int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
2767 {
2768  int id, sr, ch, ba, tag, bps;
2769 
2770  id = avctx->codec_id;
2771  sr = avctx->sample_rate;
2772  ch = avctx->channels;
2773  ba = avctx->block_align;
2774  tag = avctx->codec_tag;
2775  bps = av_get_exact_bits_per_sample(avctx->codec_id);
2776 
2777  /* codecs with an exact constant bits per sample */
2778  if (bps > 0 && ch > 0 && frame_bytes > 0 && ch < 32768 && bps < 32768)
2779  return (frame_bytes * 8LL) / (bps * ch);
2780  bps = avctx->bits_per_coded_sample;
2781 
2782  /* codecs with a fixed packet duration */
2783  switch (id) {
2784  case AV_CODEC_ID_ADPCM_ADX: return 32;
2785  case AV_CODEC_ID_ADPCM_IMA_QT: return 64;
2786  case AV_CODEC_ID_ADPCM_EA_XAS: return 128;
2787  case AV_CODEC_ID_AMR_NB:
2788  case AV_CODEC_ID_EVRC:
2789  case AV_CODEC_ID_GSM:
2790  case AV_CODEC_ID_QCELP:
2791  case AV_CODEC_ID_RA_288: return 160;
2792  case AV_CODEC_ID_AMR_WB:
2793  case AV_CODEC_ID_GSM_MS: return 320;
2794  case AV_CODEC_ID_MP1: return 384;
2795  case AV_CODEC_ID_ATRAC1: return 512;
2796  case AV_CODEC_ID_ATRAC3: return 1024;
2797  case AV_CODEC_ID_MP2:
2798  case AV_CODEC_ID_MUSEPACK7: return 1152;
2799  case AV_CODEC_ID_AC3: return 1536;
2800  }
2801 
2802  if (sr > 0) {
2803  /* calc from sample rate */
2804  if (id == AV_CODEC_ID_TTA)
2805  return 256 * sr / 245;
2806 
2807  if (ch > 0) {
2808  /* calc from sample rate and channels */
2809  if (id == AV_CODEC_ID_BINKAUDIO_DCT)
2810  return (480 << (sr / 22050)) / ch;
2811  }
2812  }
2813 
2814  if (ba > 0) {
2815  /* calc from block_align */
2816  if (id == AV_CODEC_ID_SIPR) {
2817  switch (ba) {
2818  case 20: return 160;
2819  case 19: return 144;
2820  case 29: return 288;
2821  case 37: return 480;
2822  }
2823  } else if (id == AV_CODEC_ID_ILBC) {
2824  switch (ba) {
2825  case 38: return 160;
2826  case 50: return 240;
2827  }
2828  }
2829  }
2830 
2831  if (frame_bytes > 0) {
2832  /* calc from frame_bytes only */
2833  if (id == AV_CODEC_ID_TRUESPEECH)
2834  return 240 * (frame_bytes / 32);
2835  if (id == AV_CODEC_ID_NELLYMOSER)
2836  return 256 * (frame_bytes / 64);
2837  if (id == AV_CODEC_ID_RA_144)
2838  return 160 * (frame_bytes / 20);
2839  if (id == AV_CODEC_ID_G723_1)
2840  return 240 * (frame_bytes / 24);
2841 
2842  if (bps > 0) {
2843  /* calc from frame_bytes and bits_per_coded_sample */
2844  if (id == AV_CODEC_ID_ADPCM_G726)
2845  return frame_bytes * 8 / bps;
2846  }
2847 
2848  if (ch > 0) {
2849  /* calc from frame_bytes and channels */
2850  switch (id) {
2851  case AV_CODEC_ID_ADPCM_AFC:
2852  return frame_bytes / (9 * ch) * 16;
2853  case AV_CODEC_ID_ADPCM_DTK:
2854  return frame_bytes / (16 * ch) * 28;
2855  case AV_CODEC_ID_ADPCM_4XM:
2856  case AV_CODEC_ID_ADPCM_IMA_ISS:
2857  return (frame_bytes - 4 * ch) * 2 / ch;
2858  case AV_CODEC_ID_ADPCM_IMA_SMJPEG:
2859  return (frame_bytes - 4) * 2 / ch;
2860  case AV_CODEC_ID_ADPCM_IMA_AMV:
2861  return (frame_bytes - 8) * 2 / ch;
2862  case AV_CODEC_ID_ADPCM_XA:
2863  return (frame_bytes / 128) * 224 / ch;
2864  case AV_CODEC_ID_INTERPLAY_DPCM:
2865  return (frame_bytes - 6 - ch) / ch;
2866  case AV_CODEC_ID_ROQ_DPCM:
2867  return (frame_bytes - 8) / ch;
2868  case AV_CODEC_ID_XAN_DPCM:
2869  return (frame_bytes - 2 * ch) / ch;
2870  case AV_CODEC_ID_MACE3:
2871  return 3 * frame_bytes / ch;
2872  case AV_CODEC_ID_MACE6:
2873  return 6 * frame_bytes / ch;
2874  case AV_CODEC_ID_PCM_LXF:
2875  return 2 * (frame_bytes / (5 * ch));
2876  case AV_CODEC_ID_IAC:
2877  case AV_CODEC_ID_IMC:
2878  return 4 * frame_bytes / ch;
2879  }
2880 
2881  if (tag) {
2882  /* calc from frame_bytes, channels, and codec_tag */
2883  if (id == AV_CODEC_ID_SOL_DPCM) {
2884  if (tag == 3)
2885  return frame_bytes / ch;
2886  else
2887  return frame_bytes * 2 / ch;
2888  }
2889  }
2890 
2891  if (ba > 0) {
2892  /* calc from frame_bytes, channels, and block_align */
2893  int blocks = frame_bytes / ba;
2894  switch (avctx->codec_id) {
2895  case AV_CODEC_ID_ADPCM_IMA_WAV:
2896  return blocks * (1 + (ba - 4 * ch) / (4 * ch) * 8);
2897  case AV_CODEC_ID_ADPCM_IMA_DK3:
2898  return blocks * (((ba - 16) * 2 / 3 * 4) / ch);
2899  case AV_CODEC_ID_ADPCM_IMA_DK4:
2900  return blocks * (1 + (ba - 4 * ch) * 2 / ch);
2901  case AV_CODEC_ID_ADPCM_IMA_RAD:
2902  return blocks * ((ba - 4 * ch) * 2 / ch);
2903  case AV_CODEC_ID_ADPCM_MS:
2904  return blocks * (2 + (ba - 7 * ch) * 2 / ch);
2905  }
2906  }
2907 
2908  if (bps > 0) {
2909  /* calc from frame_bytes, channels, and bits_per_coded_sample */
2910  switch (avctx->codec_id) {
2911  case AV_CODEC_ID_PCM_DVD:
2912  if(bps<4)
2913  return 0;
2914  return 2 * (frame_bytes / ((bps * 2 / 8) * ch));
2915  case AV_CODEC_ID_PCM_BLURAY:
2916  if(bps<4)
2917  return 0;
2918  return frame_bytes / ((FFALIGN(ch, 2) * bps) / 8);
2919  case AV_CODEC_ID_S302M:
2920  return 2 * (frame_bytes / ((bps + 4) / 4)) / ch;
2921  }
2922  }
2923  }
2924  }
2925 
2926  return 0;
2927 }
2928 
2929 #if !HAVE_THREADS
2930 int ff_thread_init(AVCodecContext *s)
2931 {
2932  return -1;
2933 }
2934 
2935 #endif
2936 
2937 unsigned int av_xiphlacing(unsigned char *s, unsigned int v)
2938 {
2939  unsigned int n = 0;
2940 
2941  while (v >= 0xff) {
2942  *s++ = 0xff;
2943  v -= 0xff;
2944  n++;
2945  }
2946  *s = v;
2947  n++;
2948  return n;
2949 }
2950 
2951 int ff_match_2uint16(const uint16_t(*tab)[2], int size, int a, int b)
2952 {
2953  int i;
2954  for (i = 0; i < size && !(tab[i][0] == a && tab[i][1] == b); i++) ;
2955  return i;
2956 }
2957 
2958 #if FF_API_MISSING_SAMPLE
2959 void av_log_missing_feature(void *avc, const char *feature, int want_sample)
2960 {
2961  av_log(avc, AV_LOG_WARNING, "%s is not implemented. Update your FFmpeg "
2962  "version to the newest one from Git. If the problem still "
2963  "occurs, it means that your file has a feature which has not "
2964  "been implemented.\n", feature);
2965  if(want_sample)
2966  av_log_ask_for_sample(avc, NULL);
2967 }
2968 
2969 void av_log_ask_for_sample(void *avc, const char *msg, ...)
2970 {
2971  va_list argument_list;
2972 
2973  va_start(argument_list, msg);
2974 
2975  if (msg)
2976  av_vlog(avc, AV_LOG_WARNING, msg, argument_list);
2977  av_log(avc, AV_LOG_WARNING, "If you want to help, upload a sample "
2978  "of this file to ftp://upload.ffmpeg.org/MPlayer/incoming/ "
2979  "and contact the ffmpeg-devel mailing list.\n");
2980 
2981  va_end(argument_list);
2982 }
2983 #endif /* FF_API_MISSING_SAMPLE */
2984 
2985 static AVHWAccel *first_hwaccel = NULL;
2986 
2987 void av_register_hwaccel(AVHWAccel *hwaccel)
2988 {
2989  AVHWAccel **p = &first_hwaccel;
2990  while (*p)
2991  p = &(*p)->next;
2992  *p = hwaccel;
2993  hwaccel->next = NULL;
2994 }
2995 
2996 AVHWAccel *av_hwaccel_next(AVHWAccel *hwaccel)
2997 {
2998  return hwaccel ? hwaccel->next : first_hwaccel;
2999 }
3000 
3001 AVHWAccel *ff_find_hwaccel(enum AVCodecID codec_id, enum AVPixelFormat pix_fmt)
3002 {
3003  AVHWAccel *hwaccel = NULL;
3004 
3005  while ((hwaccel = av_hwaccel_next(hwaccel)))
3006  if (hwaccel->id == codec_id
3007  && hwaccel->pix_fmt == pix_fmt)
3008  return hwaccel;
3009  return NULL;
3010 }
3011 
3012 int av_lockmgr_register(int (*cb)(void **mutex, enum AVLockOp op))
3013 {
3014  if (lockmgr_cb) {
3015  if (lockmgr_cb(&codec_mutex, AV_LOCK_DESTROY))
3016  return -1;
3017  if (lockmgr_cb(&avformat_mutex, AV_LOCK_DESTROY))
3018  return -1;
3019  }
3020 
3021  lockmgr_cb = cb;
3022 
3023  if (lockmgr_cb) {
3024  if (lockmgr_cb(&codec_mutex, AV_LOCK_CREATE))
3025  return -1;
3026  if (lockmgr_cb(&avformat_mutex, AV_LOCK_CREATE))
3027  return -1;
3028  }
3029  return 0;
3030 }
3031 
3032 int ff_lock_avcodec(AVCodecContext *log_ctx)
3033 {
3034  if (lockmgr_cb) {
3035  if ((*lockmgr_cb)(&codec_mutex, AV_LOCK_OBTAIN))
3036  return -1;
3037  }
3038  entangled_thread_counter++;
3039  if (entangled_thread_counter != 1) {
3040  av_log(log_ctx, AV_LOG_ERROR, "Insufficient thread locking around avcodec_open/close()\n");
3041  ff_avcodec_locked = 1;
3042  ff_unlock_avcodec();
3043  return AVERROR(EINVAL);
3044  }
3045  av_assert0(!ff_avcodec_locked);
3046  ff_avcodec_locked = 1;
3047  return 0;
3048 }
3049 
3050 int ff_unlock_avcodec(void)
3051 {
3052  av_assert0(ff_avcodec_locked);
3053  ff_avcodec_locked = 0;
3054  entangled_thread_counter--;
3055  if (lockmgr_cb) {
3056  if ((*lockmgr_cb)(&codec_mutex, AV_LOCK_RELEASE))
3057  return -1;
3058  }
3059  return 0;
3060 }
3061 
3062 int avpriv_lock_avformat(void)
3063 {
3064  if (lockmgr_cb) {
3065  if ((*lockmgr_cb)(&avformat_mutex, AV_LOCK_OBTAIN))
3066  return -1;
3067  }
3068  return 0;
3069 }
3070 
3071 int avpriv_unlock_avformat(void)
3072 {
3073  if (lockmgr_cb) {
3074  if ((*lockmgr_cb)(&avformat_mutex, AV_LOCK_RELEASE))
3075  return -1;
3076  }
3077  return 0;
3078 }
3079 
3080 unsigned int avpriv_toupper4(unsigned int x)
3081 {
3082  return av_toupper(x & 0xFF) +
3083  (av_toupper((x >> 8) & 0xFF) << 8) +
3084  (av_toupper((x >> 16) & 0xFF) << 16) +
3085  (av_toupper((x >> 24) & 0xFF) << 24);
3086 }
3087 
3088 int ff_thread_ref_frame(ThreadFrame *dst, ThreadFrame *src)
3089 {
3090  int ret;
3091 
3092  dst->owner = src->owner;
3093 
3094  ret = av_frame_ref(dst->f, src->f);
3095  if (ret < 0)
3096  return ret;
3097 
3098  if (src->progress &&
3099  !(dst->progress = av_buffer_ref(src->progress))) {
3100  ff_thread_release_buffer(dst->owner, dst);
3101  return AVERROR(ENOMEM);
3102  }
3103 
3104  return 0;
3105 }
3106 
3107 #if !HAVE_THREADS
3108 
3109 enum AVPixelFormat ff_thread_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
3110 {
3111  return avctx->get_format(avctx, fmt);
3112 }
3113 
3114 int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
3115 {
3116  f->owner = avctx;
3117  return ff_get_buffer(avctx, f->f, flags);
3118 }
3119 
3120 void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
3121 {
3122  av_frame_unref(f->f);
3123 }
3124 
3125 void ff_thread_finish_setup(AVCodecContext *avctx)
3126 {
3127 }
3128 
3129 void ff_thread_report_progress(ThreadFrame *f, int progress, int field)
3130 {
3131 }
3132 
3133 void ff_thread_await_progress(ThreadFrame *f, int progress, int field)
3134 {
3135 }
3136 
3137 int ff_thread_can_start_frame(AVCodecContext *avctx)
3138 {
3139  return 1;
3140 }
3141 
3142 #endif
3143 
3144 enum AVMediaType avcodec_get_type(enum AVCodecID codec_id)
3145 {
3146  AVCodec *c= avcodec_find_decoder(codec_id);
3147  if(!c)
3148  c= avcodec_find_encoder(codec_id);
3149  if(c)
3150  return c->type;
3151 
3152  if (codec_id <= AV_CODEC_ID_NONE)
3153  return AVMEDIA_TYPE_UNKNOWN;
3154  else if (codec_id < AV_CODEC_ID_FIRST_AUDIO)
3155  return AVMEDIA_TYPE_VIDEO;
3156  else if (codec_id < AV_CODEC_ID_FIRST_SUBTITLE)
3157  return AVMEDIA_TYPE_AUDIO;
3158  else if (codec_id < AV_CODEC_ID_FIRST_UNKNOWN)
3159  return AVMEDIA_TYPE_SUBTITLE;
3160 
3161  return AVMEDIA_TYPE_UNKNOWN;
3162 }
3163 
3164 int avcodec_is_open(AVCodecContext *s)
3165 {
3166  return !!s->internal;
3167 }
3168 
3169 int avpriv_bprint_to_extradata(AVCodecContext *avctx, struct AVBPrint *buf)
3170 {
3171  int ret;
3172  char *str;
3173 
3174  ret = av_bprint_finalize(buf, &str);
3175  if (ret < 0)
3176  return ret;
3177  avctx->extradata = str;
3178  /* Note: the string is NUL terminated (so extradata can be read as a
3179  * string), but the ending character is not accounted in the size (in
3180  * binary formats you are likely not supposed to mux that character). When
3181  * extradata is copied, it is also padded with FF_INPUT_BUFFER_PADDING_SIZE
3182  * zeros. */
3183  avctx->extradata_size = buf->len;
3184  return 0;
3185 }
3186 
3187 const uint8_t *avpriv_find_start_code(const uint8_t *av_restrict p,
3188  const uint8_t *end,
3189  uint32_t *av_restrict state)
3190 {
3191  int i;
3192 
3193  assert(p <= end);
3194  if (p >= end)
3195  return end;
3196 
3197  for (i = 0; i < 3; i++) {
3198  uint32_t tmp = *state << 8;
3199  *state = tmp + *(p++);
3200  if (tmp == 0x100 || p == end)
3201  return p;
3202  }
3203 
3204  while (p < end) {
3205  if (p[-1] > 1 ) p += 3;
3206  else if (p[-2] ) p += 2;
3207  else if (p[-3]|(p[-1]-1)) p++;
3208  else {
3209  p++;
3210  break;
3211  }
3212  }
3213 
3214  p = FFMIN(p, end) - 4;
3215  *state = AV_RB32(p);
3216 
3217  return p + 4;
3218 }
Generated on Thu May 23 2013 19:20:57 for FFmpeg by   doxygen 1.8.2