lavc/utils: avcodec_string: dump field order when known
[ffmpeg.git] / libavcodec / utils.c
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/atomic.h"
30 #include "libavutil/attributes.h"
31 #include "libavutil/avassert.h"
32 #include "libavutil/avstring.h"
33 #include "libavutil/bprint.h"
34 #include "libavutil/channel_layout.h"
35 #include "libavutil/crc.h"
36 #include "libavutil/frame.h"
37 #include "libavutil/hwcontext.h"
38 #include "libavutil/internal.h"
39 #include "libavutil/mathematics.h"
40 #include "libavutil/mem_internal.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/imgutils.h"
43 #include "libavutil/samplefmt.h"
44 #include "libavutil/dict.h"
45 #include "libavutil/thread.h"
46 #include "avcodec.h"
47 #include "libavutil/opt.h"
48 #include "me_cmp.h"
49 #include "mpegvideo.h"
50 #include "thread.h"
51 #include "frame_thread_encoder.h"
52 #include "internal.h"
53 #include "raw.h"
54 #include "bytestream.h"
55 #include "version.h"
56 #include <stdlib.h>
57 #include <stdarg.h>
58 #include <limits.h>
59 #include <float.h>
60 #if CONFIG_ICONV
61 # include <iconv.h>
62 #endif
63
64 #include "libavutil/ffversion.h"
65 const char av_codec_ffversion[] = "FFmpeg version " FFMPEG_VERSION;
66
67 #if HAVE_PTHREADS || HAVE_W32THREADS || HAVE_OS2THREADS
68 static int default_lockmgr_cb(void **arg, enum AVLockOp op)
69 {
70     void * volatile * mutex = arg;
71     int err;
72
73     switch (op) {
74     case AV_LOCK_CREATE:
75         return 0;
76     case AV_LOCK_OBTAIN:
77         if (!*mutex) {
78             pthread_mutex_t *tmp = av_malloc(sizeof(pthread_mutex_t));
79             if (!tmp)
80                 return AVERROR(ENOMEM);
81             if ((err = pthread_mutex_init(tmp, NULL))) {
82                 av_free(tmp);
83                 return AVERROR(err);
84             }
85             if (avpriv_atomic_ptr_cas(mutex, NULL, tmp)) {
86                 pthread_mutex_destroy(tmp);
87                 av_free(tmp);
88             }
89         }
90
91         if ((err = pthread_mutex_lock(*mutex)))
92             return AVERROR(err);
93
94         return 0;
95     case AV_LOCK_RELEASE:
96         if ((err = pthread_mutex_unlock(*mutex)))
97             return AVERROR(err);
98
99         return 0;
100     case AV_LOCK_DESTROY:
101         if (*mutex)
102             pthread_mutex_destroy(*mutex);
103         av_free(*mutex);
104         avpriv_atomic_ptr_cas(mutex, *mutex, NULL);
105         return 0;
106     }
107     return 1;
108 }
109 static int (*lockmgr_cb)(void **mutex, enum AVLockOp op) = default_lockmgr_cb;
110 #else
111 static int (*lockmgr_cb)(void **mutex, enum AVLockOp op) = NULL;
112 #endif
113
114
115 volatile int ff_avcodec_locked;
116 static int volatile entangled_thread_counter = 0;
117 static void *codec_mutex;
118 static void *avformat_mutex;
119
120 void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
121 {
122     uint8_t **p = ptr;
123     if (min_size > SIZE_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
124         av_freep(p);
125         *size = 0;
126         return;
127     }
128     if (!ff_fast_malloc(p, size, min_size + AV_INPUT_BUFFER_PADDING_SIZE, 1))
129         memset(*p + min_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
130 }
131
132 void av_fast_padded_mallocz(void *ptr, unsigned int *size, size_t min_size)
133 {
134     uint8_t **p = ptr;
135     if (min_size > SIZE_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
136         av_freep(p);
137         *size = 0;
138         return;
139     }
140     if (!ff_fast_malloc(p, size, min_size + AV_INPUT_BUFFER_PADDING_SIZE, 1))
141         memset(*p, 0, min_size + AV_INPUT_BUFFER_PADDING_SIZE);
142 }
143
144 /* encoder management */
145 static AVCodec *first_avcodec = NULL;
146 static AVCodec **last_avcodec = &first_avcodec;
147
148 AVCodec *av_codec_next(const AVCodec *c)
149 {
150     if (c)
151         return c->next;
152     else
153         return first_avcodec;
154 }
155
156 static av_cold void avcodec_init(void)
157 {
158     static int initialized = 0;
159
160     if (initialized != 0)
161         return;
162     initialized = 1;
163
164     if (CONFIG_ME_CMP)
165         ff_me_cmp_init_static();
166 }
167
168 int av_codec_is_encoder(const AVCodec *codec)
169 {
170     return codec && (codec->encode_sub || codec->encode2 ||codec->send_frame);
171 }
172
173 int av_codec_is_decoder(const AVCodec *codec)
174 {
175     return codec && (codec->decode || codec->send_packet);
176 }
177
178 av_cold void avcodec_register(AVCodec *codec)
179 {
180     AVCodec **p;
181     avcodec_init();
182     p = last_avcodec;
183     codec->next = NULL;
184
185     while(*p || avpriv_atomic_ptr_cas((void * volatile *)p, NULL, codec))
186         p = &(*p)->next;
187     last_avcodec = &codec->next;
188
189     if (codec->init_static_data)
190         codec->init_static_data(codec);
191 }
192
193 #if FF_API_EMU_EDGE
194 unsigned avcodec_get_edge_width(void)
195 {
196     return EDGE_WIDTH;
197 }
198 #endif
199
200 #if FF_API_SET_DIMENSIONS
201 void avcodec_set_dimensions(AVCodecContext *s, int width, int height)
202 {
203     int ret = ff_set_dimensions(s, width, height);
204     if (ret < 0) {
205         av_log(s, AV_LOG_WARNING, "Failed to set dimensions %d %d\n", width, height);
206     }
207 }
208 #endif
209
210 int ff_set_dimensions(AVCodecContext *s, int width, int height)
211 {
212     int ret = av_image_check_size(width, height, 0, s);
213
214     if (ret < 0)
215         width = height = 0;
216
217     s->coded_width  = width;
218     s->coded_height = height;
219     s->width        = AV_CEIL_RSHIFT(width,  s->lowres);
220     s->height       = AV_CEIL_RSHIFT(height, s->lowres);
221
222     return ret;
223 }
224
225 int ff_set_sar(AVCodecContext *avctx, AVRational sar)
226 {
227     int ret = av_image_check_sar(avctx->width, avctx->height, sar);
228
229     if (ret < 0) {
230         av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %d/%d\n",
231                sar.num, sar.den);
232         avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
233         return ret;
234     } else {
235         avctx->sample_aspect_ratio = sar;
236     }
237     return 0;
238 }
239
240 int ff_side_data_update_matrix_encoding(AVFrame *frame,
241                                         enum AVMatrixEncoding matrix_encoding)
242 {
243     AVFrameSideData *side_data;
244     enum AVMatrixEncoding *data;
245
246     side_data = av_frame_get_side_data(frame, AV_FRAME_DATA_MATRIXENCODING);
247     if (!side_data)
248         side_data = av_frame_new_side_data(frame, AV_FRAME_DATA_MATRIXENCODING,
249                                            sizeof(enum AVMatrixEncoding));
250
251     if (!side_data)
252         return AVERROR(ENOMEM);
253
254     data  = (enum AVMatrixEncoding*)side_data->data;
255     *data = matrix_encoding;
256
257     return 0;
258 }
259
260 void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height,
261                                int linesize_align[AV_NUM_DATA_POINTERS])
262 {
263     int i;
264     int w_align = 1;
265     int h_align = 1;
266     AVPixFmtDescriptor const *desc = av_pix_fmt_desc_get(s->pix_fmt);
267
268     if (desc) {
269         w_align = 1 << desc->log2_chroma_w;
270         h_align = 1 << desc->log2_chroma_h;
271     }
272
273     switch (s->pix_fmt) {
274     case AV_PIX_FMT_YUV420P:
275     case AV_PIX_FMT_YUYV422:
276     case AV_PIX_FMT_YVYU422:
277     case AV_PIX_FMT_UYVY422:
278     case AV_PIX_FMT_YUV422P:
279     case AV_PIX_FMT_YUV440P:
280     case AV_PIX_FMT_YUV444P:
281     case AV_PIX_FMT_GBRP:
282     case AV_PIX_FMT_GBRAP:
283     case AV_PIX_FMT_GRAY8:
284     case AV_PIX_FMT_GRAY16BE:
285     case AV_PIX_FMT_GRAY16LE:
286     case AV_PIX_FMT_YUVJ420P:
287     case AV_PIX_FMT_YUVJ422P:
288     case AV_PIX_FMT_YUVJ440P:
289     case AV_PIX_FMT_YUVJ444P:
290     case AV_PIX_FMT_YUVA420P:
291     case AV_PIX_FMT_YUVA422P:
292     case AV_PIX_FMT_YUVA444P:
293     case AV_PIX_FMT_YUV420P9LE:
294     case AV_PIX_FMT_YUV420P9BE:
295     case AV_PIX_FMT_YUV420P10LE:
296     case AV_PIX_FMT_YUV420P10BE:
297     case AV_PIX_FMT_YUV420P12LE:
298     case AV_PIX_FMT_YUV420P12BE:
299     case AV_PIX_FMT_YUV420P14LE:
300     case AV_PIX_FMT_YUV420P14BE:
301     case AV_PIX_FMT_YUV420P16LE:
302     case AV_PIX_FMT_YUV420P16BE:
303     case AV_PIX_FMT_YUVA420P9LE:
304     case AV_PIX_FMT_YUVA420P9BE:
305     case AV_PIX_FMT_YUVA420P10LE:
306     case AV_PIX_FMT_YUVA420P10BE:
307     case AV_PIX_FMT_YUVA420P16LE:
308     case AV_PIX_FMT_YUVA420P16BE:
309     case AV_PIX_FMT_YUV422P9LE:
310     case AV_PIX_FMT_YUV422P9BE:
311     case AV_PIX_FMT_YUV422P10LE:
312     case AV_PIX_FMT_YUV422P10BE:
313     case AV_PIX_FMT_YUV422P12LE:
314     case AV_PIX_FMT_YUV422P12BE:
315     case AV_PIX_FMT_YUV422P14LE:
316     case AV_PIX_FMT_YUV422P14BE:
317     case AV_PIX_FMT_YUV422P16LE:
318     case AV_PIX_FMT_YUV422P16BE:
319     case AV_PIX_FMT_YUVA422P9LE:
320     case AV_PIX_FMT_YUVA422P9BE:
321     case AV_PIX_FMT_YUVA422P10LE:
322     case AV_PIX_FMT_YUVA422P10BE:
323     case AV_PIX_FMT_YUVA422P16LE:
324     case AV_PIX_FMT_YUVA422P16BE:
325     case AV_PIX_FMT_YUV440P10LE:
326     case AV_PIX_FMT_YUV440P10BE:
327     case AV_PIX_FMT_YUV440P12LE:
328     case AV_PIX_FMT_YUV440P12BE:
329     case AV_PIX_FMT_YUV444P9LE:
330     case AV_PIX_FMT_YUV444P9BE:
331     case AV_PIX_FMT_YUV444P10LE:
332     case AV_PIX_FMT_YUV444P10BE:
333     case AV_PIX_FMT_YUV444P12LE:
334     case AV_PIX_FMT_YUV444P12BE:
335     case AV_PIX_FMT_YUV444P14LE:
336     case AV_PIX_FMT_YUV444P14BE:
337     case AV_PIX_FMT_YUV444P16LE:
338     case AV_PIX_FMT_YUV444P16BE:
339     case AV_PIX_FMT_YUVA444P9LE:
340     case AV_PIX_FMT_YUVA444P9BE:
341     case AV_PIX_FMT_YUVA444P10LE:
342     case AV_PIX_FMT_YUVA444P10BE:
343     case AV_PIX_FMT_YUVA444P16LE:
344     case AV_PIX_FMT_YUVA444P16BE:
345     case AV_PIX_FMT_GBRP9LE:
346     case AV_PIX_FMT_GBRP9BE:
347     case AV_PIX_FMT_GBRP10LE:
348     case AV_PIX_FMT_GBRP10BE:
349     case AV_PIX_FMT_GBRP12LE:
350     case AV_PIX_FMT_GBRP12BE:
351     case AV_PIX_FMT_GBRP14LE:
352     case AV_PIX_FMT_GBRP14BE:
353     case AV_PIX_FMT_GBRP16LE:
354     case AV_PIX_FMT_GBRP16BE:
355     case AV_PIX_FMT_GBRAP12LE:
356     case AV_PIX_FMT_GBRAP12BE:
357     case AV_PIX_FMT_GBRAP16LE:
358     case AV_PIX_FMT_GBRAP16BE:
359         w_align = 16; //FIXME assume 16 pixel per macroblock
360         h_align = 16 * 2; // interlaced needs 2 macroblocks height
361         break;
362     case AV_PIX_FMT_YUV411P:
363     case AV_PIX_FMT_YUVJ411P:
364     case AV_PIX_FMT_UYYVYY411:
365         w_align = 32;
366         h_align = 16 * 2;
367         break;
368     case AV_PIX_FMT_YUV410P:
369         if (s->codec_id == AV_CODEC_ID_SVQ1) {
370             w_align = 64;
371             h_align = 64;
372         }
373         break;
374     case AV_PIX_FMT_RGB555:
375         if (s->codec_id == AV_CODEC_ID_RPZA) {
376             w_align = 4;
377             h_align = 4;
378         }
379         break;
380     case AV_PIX_FMT_PAL8:
381     case AV_PIX_FMT_BGR8:
382     case AV_PIX_FMT_RGB8:
383         if (s->codec_id == AV_CODEC_ID_SMC ||
384             s->codec_id == AV_CODEC_ID_CINEPAK) {
385             w_align = 4;
386             h_align = 4;
387         }
388         if (s->codec_id == AV_CODEC_ID_JV) {
389             w_align = 8;
390             h_align = 8;
391         }
392         break;
393     case AV_PIX_FMT_BGR24:
394         if ((s->codec_id == AV_CODEC_ID_MSZH) ||
395             (s->codec_id == AV_CODEC_ID_ZLIB)) {
396             w_align = 4;
397             h_align = 4;
398         }
399         break;
400     case AV_PIX_FMT_RGB24:
401         if (s->codec_id == AV_CODEC_ID_CINEPAK) {
402             w_align = 4;
403             h_align = 4;
404         }
405         break;
406     default:
407         break;
408     }
409
410     if (s->codec_id == AV_CODEC_ID_IFF_ILBM) {
411         w_align = FFMAX(w_align, 8);
412     }
413
414     *width  = FFALIGN(*width, w_align);
415     *height = FFALIGN(*height, h_align);
416     if (s->codec_id == AV_CODEC_ID_H264 || s->lowres) {
417         // some of the optimized chroma MC reads one line too much
418         // which is also done in mpeg decoders with lowres > 0
419         *height += 2;
420
421         // H.264 uses edge emulation for out of frame motion vectors, for this
422         // it requires a temporary area large enough to hold a 21x21 block,
423         // increasing witdth ensure that the temporary area is large enough,
424         // the next rounded up width is 32
425         *width = FFMAX(*width, 32);
426     }
427
428     for (i = 0; i < 4; i++)
429         linesize_align[i] = STRIDE_ALIGN;
430 }
431
432 void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height)
433 {
434     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->pix_fmt);
435     int chroma_shift = desc->log2_chroma_w;
436     int linesize_align[AV_NUM_DATA_POINTERS];
437     int align;
438
439     avcodec_align_dimensions2(s, width, height, linesize_align);
440     align               = FFMAX(linesize_align[0], linesize_align[3]);
441     linesize_align[1] <<= chroma_shift;
442     linesize_align[2] <<= chroma_shift;
443     align               = FFMAX3(align, linesize_align[1], linesize_align[2]);
444     *width              = FFALIGN(*width, align);
445 }
446
447 int avcodec_enum_to_chroma_pos(int *xpos, int *ypos, enum AVChromaLocation pos)
448 {
449     if (pos <= AVCHROMA_LOC_UNSPECIFIED || pos >= AVCHROMA_LOC_NB)
450         return AVERROR(EINVAL);
451     pos--;
452
453     *xpos = (pos&1) * 128;
454     *ypos = ((pos>>1)^(pos<4)) * 128;
455
456     return 0;
457 }
458
459 enum AVChromaLocation avcodec_chroma_pos_to_enum(int xpos, int ypos)
460 {
461     int pos, xout, yout;
462
463     for (pos = AVCHROMA_LOC_UNSPECIFIED + 1; pos < AVCHROMA_LOC_NB; pos++) {
464         if (avcodec_enum_to_chroma_pos(&xout, &yout, pos) == 0 && xout == xpos && yout == ypos)
465             return pos;
466     }
467     return AVCHROMA_LOC_UNSPECIFIED;
468 }
469
470 int avcodec_fill_audio_frame(AVFrame *frame, int nb_channels,
471                              enum AVSampleFormat sample_fmt, const uint8_t *buf,
472                              int buf_size, int align)
473 {
474     int ch, planar, needed_size, ret = 0;
475
476     needed_size = av_samples_get_buffer_size(NULL, nb_channels,
477                                              frame->nb_samples, sample_fmt,
478                                              align);
479     if (buf_size < needed_size)
480         return AVERROR(EINVAL);
481
482     planar = av_sample_fmt_is_planar(sample_fmt);
483     if (planar && nb_channels > AV_NUM_DATA_POINTERS) {
484         if (!(frame->extended_data = av_mallocz_array(nb_channels,
485                                                 sizeof(*frame->extended_data))))
486             return AVERROR(ENOMEM);
487     } else {
488         frame->extended_data = frame->data;
489     }
490
491     if ((ret = av_samples_fill_arrays(frame->extended_data, &frame->linesize[0],
492                                       (uint8_t *)(intptr_t)buf, nb_channels, frame->nb_samples,
493                                       sample_fmt, align)) < 0) {
494         if (frame->extended_data != frame->data)
495             av_freep(&frame->extended_data);
496         return ret;
497     }
498     if (frame->extended_data != frame->data) {
499         for (ch = 0; ch < AV_NUM_DATA_POINTERS; ch++)
500             frame->data[ch] = frame->extended_data[ch];
501     }
502
503     return ret;
504 }
505
506 static int update_frame_pool(AVCodecContext *avctx, AVFrame *frame)
507 {
508     FramePool *pool = avctx->internal->pool;
509     int i, ret;
510
511     switch (avctx->codec_type) {
512     case AVMEDIA_TYPE_VIDEO: {
513         uint8_t *data[4];
514         int linesize[4];
515         int size[4] = { 0 };
516         int w = frame->width;
517         int h = frame->height;
518         int tmpsize, unaligned;
519
520         if (pool->format == frame->format &&
521             pool->width == frame->width && pool->height == frame->height)
522             return 0;
523
524         avcodec_align_dimensions2(avctx, &w, &h, pool->stride_align);
525
526         do {
527             // NOTE: do not align linesizes individually, this breaks e.g. assumptions
528             // that linesize[0] == 2*linesize[1] in the MPEG-encoder for 4:2:2
529             ret = av_image_fill_linesizes(linesize, avctx->pix_fmt, w);
530             if (ret < 0)
531                 return ret;
532             // increase alignment of w for next try (rhs gives the lowest bit set in w)
533             w += w & ~(w - 1);
534
535             unaligned = 0;
536             for (i = 0; i < 4; i++)
537                 unaligned |= linesize[i] % pool->stride_align[i];
538         } while (unaligned);
539
540         tmpsize = av_image_fill_pointers(data, avctx->pix_fmt, h,
541                                          NULL, linesize);
542         if (tmpsize < 0)
543             return -1;
544
545         for (i = 0; i < 3 && data[i + 1]; i++)
546             size[i] = data[i + 1] - data[i];
547         size[i] = tmpsize - (data[i] - data[0]);
548
549         for (i = 0; i < 4; i++) {
550             av_buffer_pool_uninit(&pool->pools[i]);
551             pool->linesize[i] = linesize[i];
552             if (size[i]) {
553                 pool->pools[i] = av_buffer_pool_init(size[i] + 16 + STRIDE_ALIGN - 1,
554                                                      CONFIG_MEMORY_POISONING ?
555                                                         NULL :
556                                                         av_buffer_allocz);
557                 if (!pool->pools[i]) {
558                     ret = AVERROR(ENOMEM);
559                     goto fail;
560                 }
561             }
562         }
563         pool->format = frame->format;
564         pool->width  = frame->width;
565         pool->height = frame->height;
566
567         break;
568         }
569     case AVMEDIA_TYPE_AUDIO: {
570         int ch     = av_frame_get_channels(frame); //av_get_channel_layout_nb_channels(frame->channel_layout);
571         int planar = av_sample_fmt_is_planar(frame->format);
572         int planes = planar ? ch : 1;
573
574         if (pool->format == frame->format && pool->planes == planes &&
575             pool->channels == ch && frame->nb_samples == pool->samples)
576             return 0;
577
578         av_buffer_pool_uninit(&pool->pools[0]);
579         ret = av_samples_get_buffer_size(&pool->linesize[0], ch,
580                                          frame->nb_samples, frame->format, 0);
581         if (ret < 0)
582             goto fail;
583
584         pool->pools[0] = av_buffer_pool_init(pool->linesize[0], NULL);
585         if (!pool->pools[0]) {
586             ret = AVERROR(ENOMEM);
587             goto fail;
588         }
589
590         pool->format     = frame->format;
591         pool->planes     = planes;
592         pool->channels   = ch;
593         pool->samples = frame->nb_samples;
594         break;
595         }
596     default: av_assert0(0);
597     }
598     return 0;
599 fail:
600     for (i = 0; i < 4; i++)
601         av_buffer_pool_uninit(&pool->pools[i]);
602     pool->format = -1;
603     pool->planes = pool->channels = pool->samples = 0;
604     pool->width  = pool->height = 0;
605     return ret;
606 }
607
608 static int audio_get_buffer(AVCodecContext *avctx, AVFrame *frame)
609 {
610     FramePool *pool = avctx->internal->pool;
611     int planes = pool->planes;
612     int i;
613
614     frame->linesize[0] = pool->linesize[0];
615
616     if (planes > AV_NUM_DATA_POINTERS) {
617         frame->extended_data = av_mallocz_array(planes, sizeof(*frame->extended_data));
618         frame->nb_extended_buf = planes - AV_NUM_DATA_POINTERS;
619         frame->extended_buf  = av_mallocz_array(frame->nb_extended_buf,
620                                           sizeof(*frame->extended_buf));
621         if (!frame->extended_data || !frame->extended_buf) {
622             av_freep(&frame->extended_data);
623             av_freep(&frame->extended_buf);
624             return AVERROR(ENOMEM);
625         }
626     } else {
627         frame->extended_data = frame->data;
628         av_assert0(frame->nb_extended_buf == 0);
629     }
630
631     for (i = 0; i < FFMIN(planes, AV_NUM_DATA_POINTERS); i++) {
632         frame->buf[i] = av_buffer_pool_get(pool->pools[0]);
633         if (!frame->buf[i])
634             goto fail;
635         frame->extended_data[i] = frame->data[i] = frame->buf[i]->data;
636     }
637     for (i = 0; i < frame->nb_extended_buf; i++) {
638         frame->extended_buf[i] = av_buffer_pool_get(pool->pools[0]);
639         if (!frame->extended_buf[i])
640             goto fail;
641         frame->extended_data[i + AV_NUM_DATA_POINTERS] = frame->extended_buf[i]->data;
642     }
643
644     if (avctx->debug & FF_DEBUG_BUFFERS)
645         av_log(avctx, AV_LOG_DEBUG, "default_get_buffer called on frame %p", frame);
646
647     return 0;
648 fail:
649     av_frame_unref(frame);
650     return AVERROR(ENOMEM);
651 }
652
653 static int video_get_buffer(AVCodecContext *s, AVFrame *pic)
654 {
655     FramePool *pool = s->internal->pool;
656     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pic->format);
657     int i;
658
659     if (pic->data[0] || pic->data[1] || pic->data[2] || pic->data[3]) {
660         av_log(s, AV_LOG_ERROR, "pic->data[*]!=NULL in avcodec_default_get_buffer\n");
661         return -1;
662     }
663
664     if (!desc) {
665         av_log(s, AV_LOG_ERROR,
666             "Unable to get pixel format descriptor for format %s\n",
667             av_get_pix_fmt_name(pic->format));
668         return AVERROR(EINVAL);
669     }
670
671     memset(pic->data, 0, sizeof(pic->data));
672     pic->extended_data = pic->data;
673
674     for (i = 0; i < 4 && pool->pools[i]; i++) {
675         pic->linesize[i] = pool->linesize[i];
676
677         pic->buf[i] = av_buffer_pool_get(pool->pools[i]);
678         if (!pic->buf[i])
679             goto fail;
680
681         pic->data[i] = pic->buf[i]->data;
682     }
683     for (; i < AV_NUM_DATA_POINTERS; i++) {
684         pic->data[i] = NULL;
685         pic->linesize[i] = 0;
686     }
687     if (desc->flags & AV_PIX_FMT_FLAG_PAL ||
688         desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL)
689         avpriv_set_systematic_pal2((uint32_t *)pic->data[1], pic->format);
690
691     if (s->debug & FF_DEBUG_BUFFERS)
692         av_log(s, AV_LOG_DEBUG, "default_get_buffer called on pic %p\n", pic);
693
694     return 0;
695 fail:
696     av_frame_unref(pic);
697     return AVERROR(ENOMEM);
698 }
699
700 void ff_color_frame(AVFrame *frame, const int c[4])
701 {
702     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
703     int p, y, x;
704
705     av_assert0(desc->flags & AV_PIX_FMT_FLAG_PLANAR);
706
707     for (p = 0; p<desc->nb_components; p++) {
708         uint8_t *dst = frame->data[p];
709         int is_chroma = p == 1 || p == 2;
710         int bytes  = is_chroma ? AV_CEIL_RSHIFT(frame->width,  desc->log2_chroma_w) : frame->width;
711         int height = is_chroma ? AV_CEIL_RSHIFT(frame->height, desc->log2_chroma_h) : frame->height;
712         for (y = 0; y < height; y++) {
713             if (desc->comp[0].depth >= 9) {
714                 for (x = 0; x<bytes; x++)
715                     ((uint16_t*)dst)[x] = c[p];
716             }else
717                 memset(dst, c[p], bytes);
718             dst += frame->linesize[p];
719         }
720     }
721 }
722
723 int avcodec_default_get_buffer2(AVCodecContext *avctx, AVFrame *frame, int flags)
724 {
725     int ret;
726
727     if (avctx->hw_frames_ctx)
728         return av_hwframe_get_buffer(avctx->hw_frames_ctx, frame, 0);
729
730     if ((ret = update_frame_pool(avctx, frame)) < 0)
731         return ret;
732
733     switch (avctx->codec_type) {
734     case AVMEDIA_TYPE_VIDEO:
735         return video_get_buffer(avctx, frame);
736     case AVMEDIA_TYPE_AUDIO:
737         return audio_get_buffer(avctx, frame);
738     default:
739         return -1;
740     }
741 }
742
743 static int add_metadata_from_side_data(AVPacket *avpkt, AVFrame *frame)
744 {
745     int size;
746     const uint8_t *side_metadata;
747
748     AVDictionary **frame_md = avpriv_frame_get_metadatap(frame);
749
750     side_metadata = av_packet_get_side_data(avpkt,
751                                             AV_PKT_DATA_STRINGS_METADATA, &size);
752     return av_packet_unpack_dictionary(side_metadata, size, frame_md);
753 }
754
755 int ff_init_buffer_info(AVCodecContext *avctx, AVFrame *frame)
756 {
757     AVPacket *pkt = avctx->internal->pkt;
758     int i;
759     static const struct {
760         enum AVPacketSideDataType packet;
761         enum AVFrameSideDataType frame;
762     } sd[] = {
763         { AV_PKT_DATA_REPLAYGAIN ,                AV_FRAME_DATA_REPLAYGAIN },
764         { AV_PKT_DATA_DISPLAYMATRIX,              AV_FRAME_DATA_DISPLAYMATRIX },
765         { AV_PKT_DATA_STEREO3D,                   AV_FRAME_DATA_STEREO3D },
766         { AV_PKT_DATA_AUDIO_SERVICE_TYPE,         AV_FRAME_DATA_AUDIO_SERVICE_TYPE },
767         { AV_PKT_DATA_MASTERING_DISPLAY_METADATA, AV_FRAME_DATA_MASTERING_DISPLAY_METADATA },
768     };
769
770     if (pkt) {
771         frame->pts = pkt->pts;
772 #if FF_API_PKT_PTS
773 FF_DISABLE_DEPRECATION_WARNINGS
774         frame->pkt_pts = pkt->pts;
775 FF_ENABLE_DEPRECATION_WARNINGS
776 #endif
777         av_frame_set_pkt_pos     (frame, pkt->pos);
778         av_frame_set_pkt_duration(frame, pkt->duration);
779         av_frame_set_pkt_size    (frame, pkt->size);
780
781         for (i = 0; i < FF_ARRAY_ELEMS(sd); i++) {
782             int size;
783             uint8_t *packet_sd = av_packet_get_side_data(pkt, sd[i].packet, &size);
784             if (packet_sd) {
785                 AVFrameSideData *frame_sd = av_frame_new_side_data(frame,
786                                                                    sd[i].frame,
787                                                                    size);
788                 if (!frame_sd)
789                     return AVERROR(ENOMEM);
790
791                 memcpy(frame_sd->data, packet_sd, size);
792             }
793         }
794         add_metadata_from_side_data(pkt, frame);
795
796         if (pkt->flags & AV_PKT_FLAG_DISCARD) {
797             frame->flags |= AV_FRAME_FLAG_DISCARD;
798         } else {
799             frame->flags = (frame->flags & ~AV_FRAME_FLAG_DISCARD);
800         }
801     } else {
802         frame->pts = AV_NOPTS_VALUE;
803 #if FF_API_PKT_PTS
804 FF_DISABLE_DEPRECATION_WARNINGS
805         frame->pkt_pts = AV_NOPTS_VALUE;
806 FF_ENABLE_DEPRECATION_WARNINGS
807 #endif
808         av_frame_set_pkt_pos     (frame, -1);
809         av_frame_set_pkt_duration(frame, 0);
810         av_frame_set_pkt_size    (frame, -1);
811     }
812     frame->reordered_opaque = avctx->reordered_opaque;
813
814     if (frame->color_primaries == AVCOL_PRI_UNSPECIFIED)
815         frame->color_primaries = avctx->color_primaries;
816     if (frame->color_trc == AVCOL_TRC_UNSPECIFIED)
817         frame->color_trc = avctx->color_trc;
818     if (av_frame_get_colorspace(frame) == AVCOL_SPC_UNSPECIFIED)
819         av_frame_set_colorspace(frame, avctx->colorspace);
820     if (av_frame_get_color_range(frame) == AVCOL_RANGE_UNSPECIFIED)
821         av_frame_set_color_range(frame, avctx->color_range);
822     if (frame->chroma_location == AVCHROMA_LOC_UNSPECIFIED)
823         frame->chroma_location = avctx->chroma_sample_location;
824
825     switch (avctx->codec->type) {
826     case AVMEDIA_TYPE_VIDEO:
827         frame->format              = avctx->pix_fmt;
828         if (!frame->sample_aspect_ratio.num)
829             frame->sample_aspect_ratio = avctx->sample_aspect_ratio;
830
831         if (frame->width && frame->height &&
832             av_image_check_sar(frame->width, frame->height,
833                                frame->sample_aspect_ratio) < 0) {
834             av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
835                    frame->sample_aspect_ratio.num,
836                    frame->sample_aspect_ratio.den);
837             frame->sample_aspect_ratio = (AVRational){ 0, 1 };
838         }
839
840         break;
841     case AVMEDIA_TYPE_AUDIO:
842         if (!frame->sample_rate)
843             frame->sample_rate    = avctx->sample_rate;
844         if (frame->format < 0)
845             frame->format         = avctx->sample_fmt;
846         if (!frame->channel_layout) {
847             if (avctx->channel_layout) {
848                  if (av_get_channel_layout_nb_channels(avctx->channel_layout) !=
849                      avctx->channels) {
850                      av_log(avctx, AV_LOG_ERROR, "Inconsistent channel "
851                             "configuration.\n");
852                      return AVERROR(EINVAL);
853                  }
854
855                 frame->channel_layout = avctx->channel_layout;
856             } else {
857                 if (avctx->channels > FF_SANE_NB_CHANNELS) {
858                     av_log(avctx, AV_LOG_ERROR, "Too many channels: %d.\n",
859                            avctx->channels);
860                     return AVERROR(ENOSYS);
861                 }
862             }
863         }
864         av_frame_set_channels(frame, avctx->channels);
865         break;
866     }
867     return 0;
868 }
869
870 int ff_decode_frame_props(AVCodecContext *avctx, AVFrame *frame)
871 {
872     return ff_init_buffer_info(avctx, frame);
873 }
874
875 static void validate_avframe_allocation(AVCodecContext *avctx, AVFrame *frame)
876 {
877     if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
878         int i;
879         int num_planes = av_pix_fmt_count_planes(frame->format);
880         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
881         int flags = desc ? desc->flags : 0;
882         if (num_planes == 1 && (flags & AV_PIX_FMT_FLAG_PAL))
883             num_planes = 2;
884         for (i = 0; i < num_planes; i++) {
885             av_assert0(frame->data[i]);
886         }
887         // For now do not enforce anything for palette of pseudopal formats
888         if (num_planes == 1 && (flags & AV_PIX_FMT_FLAG_PSEUDOPAL))
889             num_planes = 2;
890         // For formats without data like hwaccel allow unused pointers to be non-NULL.
891         for (i = num_planes; num_planes > 0 && i < FF_ARRAY_ELEMS(frame->data); i++) {
892             if (frame->data[i])
893                 av_log(avctx, AV_LOG_ERROR, "Buffer returned by get_buffer2() did not zero unused plane pointers\n");
894             frame->data[i] = NULL;
895         }
896     }
897 }
898
899 static int get_buffer_internal(AVCodecContext *avctx, AVFrame *frame, int flags)
900 {
901     const AVHWAccel *hwaccel = avctx->hwaccel;
902     int override_dimensions = 1;
903     int ret;
904
905     if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
906         if ((ret = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0 || avctx->pix_fmt<0) {
907             av_log(avctx, AV_LOG_ERROR, "video_get_buffer: image parameters invalid\n");
908             return AVERROR(EINVAL);
909         }
910
911         if (frame->width <= 0 || frame->height <= 0) {
912             frame->width  = FFMAX(avctx->width,  AV_CEIL_RSHIFT(avctx->coded_width,  avctx->lowres));
913             frame->height = FFMAX(avctx->height, AV_CEIL_RSHIFT(avctx->coded_height, avctx->lowres));
914             override_dimensions = 0;
915         }
916
917         if (frame->data[0] || frame->data[1] || frame->data[2] || frame->data[3]) {
918             av_log(avctx, AV_LOG_ERROR, "pic->data[*]!=NULL in get_buffer_internal\n");
919             return AVERROR(EINVAL);
920         }
921     }
922     ret = ff_decode_frame_props(avctx, frame);
923     if (ret < 0)
924         return ret;
925
926     if (hwaccel) {
927         if (hwaccel->alloc_frame) {
928             ret = hwaccel->alloc_frame(avctx, frame);
929             goto end;
930         }
931     } else
932         avctx->sw_pix_fmt = avctx->pix_fmt;
933
934     ret = avctx->get_buffer2(avctx, frame, flags);
935     if (ret >= 0)
936         validate_avframe_allocation(avctx, frame);
937
938 end:
939     if (avctx->codec_type == AVMEDIA_TYPE_VIDEO && !override_dimensions) {
940         frame->width  = avctx->width;
941         frame->height = avctx->height;
942     }
943
944     return ret;
945 }
946
947 int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
948 {
949     int ret = get_buffer_internal(avctx, frame, flags);
950     if (ret < 0) {
951         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
952         frame->width = frame->height = 0;
953     }
954     return ret;
955 }
956
957 static int reget_buffer_internal(AVCodecContext *avctx, AVFrame *frame)
958 {
959     AVFrame *tmp;
960     int ret;
961
962     av_assert0(avctx->codec_type == AVMEDIA_TYPE_VIDEO);
963
964     if (frame->data[0] && (frame->width != avctx->width || frame->height != avctx->height || frame->format != avctx->pix_fmt)) {
965         av_log(avctx, AV_LOG_WARNING, "Picture changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s in reget buffer()\n",
966                frame->width, frame->height, av_get_pix_fmt_name(frame->format), avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
967         av_frame_unref(frame);
968     }
969
970     ff_init_buffer_info(avctx, frame);
971
972     if (!frame->data[0])
973         return ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF);
974
975     if (av_frame_is_writable(frame))
976         return ff_decode_frame_props(avctx, frame);
977
978     tmp = av_frame_alloc();
979     if (!tmp)
980         return AVERROR(ENOMEM);
981
982     av_frame_move_ref(tmp, frame);
983
984     ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF);
985     if (ret < 0) {
986         av_frame_free(&tmp);
987         return ret;
988     }
989
990     av_frame_copy(frame, tmp);
991     av_frame_free(&tmp);
992
993     return 0;
994 }
995
996 int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame)
997 {
998     int ret = reget_buffer_internal(avctx, frame);
999     if (ret < 0)
1000         av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
1001     return ret;
1002 }
1003
1004 int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2), void *arg, int *ret, int count, int size)
1005 {
1006     int i;
1007
1008     for (i = 0; i < count; i++) {
1009         int r = func(c, (char *)arg + i * size);
1010         if (ret)
1011             ret[i] = r;
1012     }
1013     emms_c();
1014     return 0;
1015 }
1016
1017 int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int jobnr, int threadnr), void *arg, int *ret, int count)
1018 {
1019     int i;
1020
1021     for (i = 0; i < count; i++) {
1022         int r = func(c, arg, i, 0);
1023         if (ret)
1024             ret[i] = r;
1025     }
1026     emms_c();
1027     return 0;
1028 }
1029
1030 enum AVPixelFormat avpriv_find_pix_fmt(const PixelFormatTag *tags,
1031                                        unsigned int fourcc)
1032 {
1033     while (tags->pix_fmt >= 0) {
1034         if (tags->fourcc == fourcc)
1035             return tags->pix_fmt;
1036         tags++;
1037     }
1038     return AV_PIX_FMT_NONE;
1039 }
1040
1041 static int is_hwaccel_pix_fmt(enum AVPixelFormat pix_fmt)
1042 {
1043     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
1044     return desc->flags & AV_PIX_FMT_FLAG_HWACCEL;
1045 }
1046
1047 enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum AVPixelFormat *fmt)
1048 {
1049     while (*fmt != AV_PIX_FMT_NONE && is_hwaccel_pix_fmt(*fmt))
1050         ++fmt;
1051     return fmt[0];
1052 }
1053
1054 static AVHWAccel *find_hwaccel(enum AVCodecID codec_id,
1055                                enum AVPixelFormat pix_fmt)
1056 {
1057     AVHWAccel *hwaccel = NULL;
1058
1059     while ((hwaccel = av_hwaccel_next(hwaccel)))
1060         if (hwaccel->id == codec_id
1061             && hwaccel->pix_fmt == pix_fmt)
1062             return hwaccel;
1063     return NULL;
1064 }
1065
1066 static int setup_hwaccel(AVCodecContext *avctx,
1067                          const enum AVPixelFormat fmt,
1068                          const char *name)
1069 {
1070     AVHWAccel *hwa = find_hwaccel(avctx->codec_id, fmt);
1071     int ret        = 0;
1072
1073     if (avctx->active_thread_type & FF_THREAD_FRAME) {
1074         av_log(avctx, AV_LOG_WARNING,
1075                "Hardware accelerated decoding with frame threading is known to be unstable and its use is discouraged.\n");
1076     }
1077
1078     if (!hwa) {
1079         av_log(avctx, AV_LOG_ERROR,
1080                "Could not find an AVHWAccel for the pixel format: %s",
1081                name);
1082         return AVERROR(ENOENT);
1083     }
1084
1085     if (hwa->capabilities & HWACCEL_CODEC_CAP_EXPERIMENTAL &&
1086         avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
1087         av_log(avctx, AV_LOG_WARNING, "Ignoring experimental hwaccel: %s\n",
1088                hwa->name);
1089         return AVERROR_PATCHWELCOME;
1090     }
1091
1092     if (hwa->priv_data_size) {
1093         avctx->internal->hwaccel_priv_data = av_mallocz(hwa->priv_data_size);
1094         if (!avctx->internal->hwaccel_priv_data)
1095             return AVERROR(ENOMEM);
1096     }
1097
1098     if (hwa->init) {
1099         ret = hwa->init(avctx);
1100         if (ret < 0) {
1101             av_freep(&avctx->internal->hwaccel_priv_data);
1102             return ret;
1103         }
1104     }
1105
1106     avctx->hwaccel = hwa;
1107
1108     return 0;
1109 }
1110
1111 int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
1112 {
1113     const AVPixFmtDescriptor *desc;
1114     enum AVPixelFormat *choices;
1115     enum AVPixelFormat ret;
1116     unsigned n = 0;
1117
1118     while (fmt[n] != AV_PIX_FMT_NONE)
1119         ++n;
1120
1121     av_assert0(n >= 1);
1122     avctx->sw_pix_fmt = fmt[n - 1];
1123     av_assert2(!is_hwaccel_pix_fmt(avctx->sw_pix_fmt));
1124
1125     choices = av_malloc_array(n + 1, sizeof(*choices));
1126     if (!choices)
1127         return AV_PIX_FMT_NONE;
1128
1129     memcpy(choices, fmt, (n + 1) * sizeof(*choices));
1130
1131     for (;;) {
1132         if (avctx->hwaccel && avctx->hwaccel->uninit)
1133             avctx->hwaccel->uninit(avctx);
1134         av_freep(&avctx->internal->hwaccel_priv_data);
1135         avctx->hwaccel = NULL;
1136
1137         av_buffer_unref(&avctx->hw_frames_ctx);
1138
1139         ret = avctx->get_format(avctx, choices);
1140
1141         desc = av_pix_fmt_desc_get(ret);
1142         if (!desc) {
1143             ret = AV_PIX_FMT_NONE;
1144             break;
1145         }
1146
1147         if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
1148             break;
1149 #if FF_API_CAP_VDPAU
1150         if (avctx->codec->capabilities&AV_CODEC_CAP_HWACCEL_VDPAU)
1151             break;
1152 #endif
1153
1154         if (avctx->hw_frames_ctx) {
1155             AVHWFramesContext *hw_frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
1156             if (hw_frames_ctx->format != ret) {
1157                 av_log(avctx, AV_LOG_ERROR, "Format returned from get_buffer() "
1158                        "does not match the format of provided AVHWFramesContext\n");
1159                 ret = AV_PIX_FMT_NONE;
1160                 break;
1161             }
1162         }
1163
1164         if (!setup_hwaccel(avctx, ret, desc->name))
1165             break;
1166
1167         /* Remove failed hwaccel from choices */
1168         for (n = 0; choices[n] != ret; n++)
1169             av_assert0(choices[n] != AV_PIX_FMT_NONE);
1170
1171         do
1172             choices[n] = choices[n + 1];
1173         while (choices[n++] != AV_PIX_FMT_NONE);
1174     }
1175
1176     av_freep(&choices);
1177     return ret;
1178 }
1179
1180 MAKE_ACCESSORS(AVCodecContext, codec, AVRational, pkt_timebase)
1181 MAKE_ACCESSORS(AVCodecContext, codec, const AVCodecDescriptor *, codec_descriptor)
1182 MAKE_ACCESSORS(AVCodecContext, codec, int, lowres)
1183 MAKE_ACCESSORS(AVCodecContext, codec, int, seek_preroll)
1184 MAKE_ACCESSORS(AVCodecContext, codec, uint16_t*, chroma_intra_matrix)
1185
1186 unsigned av_codec_get_codec_properties(const AVCodecContext *codec)
1187 {
1188     return codec->properties;
1189 }
1190
1191 int av_codec_get_max_lowres(const AVCodec *codec)
1192 {
1193     return codec->max_lowres;
1194 }
1195
1196 int avpriv_codec_get_cap_skip_frame_fill_param(const AVCodec *codec){
1197     return !!(codec->caps_internal & FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM);
1198 }
1199
1200 static void get_subtitle_defaults(AVSubtitle *sub)
1201 {
1202     memset(sub, 0, sizeof(*sub));
1203     sub->pts = AV_NOPTS_VALUE;
1204 }
1205
1206 static int64_t get_bit_rate(AVCodecContext *ctx)
1207 {
1208     int64_t bit_rate;
1209     int bits_per_sample;
1210
1211     switch (ctx->codec_type) {
1212     case AVMEDIA_TYPE_VIDEO:
1213     case AVMEDIA_TYPE_DATA:
1214     case AVMEDIA_TYPE_SUBTITLE:
1215     case AVMEDIA_TYPE_ATTACHMENT:
1216         bit_rate = ctx->bit_rate;
1217         break;
1218     case AVMEDIA_TYPE_AUDIO:
1219         bits_per_sample = av_get_bits_per_sample(ctx->codec_id);
1220         bit_rate = bits_per_sample ? ctx->sample_rate * (int64_t)ctx->channels * bits_per_sample : ctx->bit_rate;
1221         break;
1222     default:
1223         bit_rate = 0;
1224         break;
1225     }
1226     return bit_rate;
1227 }
1228
1229 int attribute_align_arg ff_codec_open2_recursive(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
1230 {
1231     int ret = 0;
1232
1233     ff_unlock_avcodec(codec);
1234
1235     ret = avcodec_open2(avctx, codec, options);
1236
1237     ff_lock_avcodec(avctx, codec);
1238     return ret;
1239 }
1240
1241 int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
1242 {
1243     int ret = 0;
1244     AVDictionary *tmp = NULL;
1245     const AVPixFmtDescriptor *pixdesc;
1246
1247     if (avcodec_is_open(avctx))
1248         return 0;
1249
1250     if ((!codec && !avctx->codec)) {
1251         av_log(avctx, AV_LOG_ERROR, "No codec provided to avcodec_open2()\n");
1252         return AVERROR(EINVAL);
1253     }
1254     if ((codec && avctx->codec && codec != avctx->codec)) {
1255         av_log(avctx, AV_LOG_ERROR, "This AVCodecContext was allocated for %s, "
1256                                     "but %s passed to avcodec_open2()\n", avctx->codec->name, codec->name);
1257         return AVERROR(EINVAL);
1258     }
1259     if (!codec)
1260         codec = avctx->codec;
1261
1262     if (avctx->extradata_size < 0 || avctx->extradata_size >= FF_MAX_EXTRADATA_SIZE)
1263         return AVERROR(EINVAL);
1264
1265     if (options)
1266         av_dict_copy(&tmp, *options, 0);
1267
1268     ret = ff_lock_avcodec(avctx, codec);
1269     if (ret < 0)
1270         return ret;
1271
1272     avctx->internal = av_mallocz(sizeof(AVCodecInternal));
1273     if (!avctx->internal) {
1274         ret = AVERROR(ENOMEM);
1275         goto end;
1276     }
1277
1278     avctx->internal->pool = av_mallocz(sizeof(*avctx->internal->pool));
1279     if (!avctx->internal->pool) {
1280         ret = AVERROR(ENOMEM);
1281         goto free_and_end;
1282     }
1283
1284     avctx->internal->to_free = av_frame_alloc();
1285     if (!avctx->internal->to_free) {
1286         ret = AVERROR(ENOMEM);
1287         goto free_and_end;
1288     }
1289
1290     avctx->internal->buffer_frame = av_frame_alloc();
1291     if (!avctx->internal->buffer_frame) {
1292         ret = AVERROR(ENOMEM);
1293         goto free_and_end;
1294     }
1295
1296     avctx->internal->buffer_pkt = av_packet_alloc();
1297     if (!avctx->internal->buffer_pkt) {
1298         ret = AVERROR(ENOMEM);
1299         goto free_and_end;
1300     }
1301
1302     if (codec->priv_data_size > 0) {
1303         if (!avctx->priv_data) {
1304             avctx->priv_data = av_mallocz(codec->priv_data_size);
1305             if (!avctx->priv_data) {
1306                 ret = AVERROR(ENOMEM);
1307                 goto end;
1308             }
1309             if (codec->priv_class) {
1310                 *(const AVClass **)avctx->priv_data = codec->priv_class;
1311                 av_opt_set_defaults(avctx->priv_data);
1312             }
1313         }
1314         if (codec->priv_class && (ret = av_opt_set_dict(avctx->priv_data, &tmp)) < 0)
1315             goto free_and_end;
1316     } else {
1317         avctx->priv_data = NULL;
1318     }
1319     if ((ret = av_opt_set_dict(avctx, &tmp)) < 0)
1320         goto free_and_end;
1321
1322     if (avctx->codec_whitelist && av_match_list(codec->name, avctx->codec_whitelist, ',') <= 0) {
1323         av_log(avctx, AV_LOG_ERROR, "Codec (%s) not on whitelist \'%s\'\n", codec->name, avctx->codec_whitelist);
1324         ret = AVERROR(EINVAL);
1325         goto free_and_end;
1326     }
1327
1328     // only call ff_set_dimensions() for non H.264/VP6F/DXV codecs so as not to overwrite previously setup dimensions
1329     if (!(avctx->coded_width && avctx->coded_height && avctx->width && avctx->height &&
1330           (avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_VP6F || avctx->codec_id == AV_CODEC_ID_DXV))) {
1331     if (avctx->coded_width && avctx->coded_height)
1332         ret = ff_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);
1333     else if (avctx->width && avctx->height)
1334         ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
1335     if (ret < 0)
1336         goto free_and_end;
1337     }
1338
1339     if ((avctx->coded_width || avctx->coded_height || avctx->width || avctx->height)
1340         && (  av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx) < 0
1341            || av_image_check_size(avctx->width,       avctx->height,       0, avctx) < 0)) {
1342         av_log(avctx, AV_LOG_WARNING, "Ignoring invalid width/height values\n");
1343         ff_set_dimensions(avctx, 0, 0);
1344     }
1345
1346     if (avctx->width > 0 && avctx->height > 0) {
1347         if (av_image_check_sar(avctx->width, avctx->height,
1348                                avctx->sample_aspect_ratio) < 0) {
1349             av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
1350                    avctx->sample_aspect_ratio.num,
1351                    avctx->sample_aspect_ratio.den);
1352             avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
1353         }
1354     }
1355
1356     /* if the decoder init function was already called previously,
1357      * free the already allocated subtitle_header before overwriting it */
1358     if (av_codec_is_decoder(codec))
1359         av_freep(&avctx->subtitle_header);
1360
1361     if (avctx->channels > FF_SANE_NB_CHANNELS) {
1362         ret = AVERROR(EINVAL);
1363         goto free_and_end;
1364     }
1365
1366     avctx->codec = codec;
1367     if ((avctx->codec_type == AVMEDIA_TYPE_UNKNOWN || avctx->codec_type == codec->type) &&
1368         avctx->codec_id == AV_CODEC_ID_NONE) {
1369         avctx->codec_type = codec->type;
1370         avctx->codec_id   = codec->id;
1371     }
1372     if (avctx->codec_id != codec->id || (avctx->codec_type != codec->type
1373                                          && avctx->codec_type != AVMEDIA_TYPE_ATTACHMENT)) {
1374         av_log(avctx, AV_LOG_ERROR, "Codec type or id mismatches\n");
1375         ret = AVERROR(EINVAL);
1376         goto free_and_end;
1377     }
1378     avctx->frame_number = 0;
1379     avctx->codec_descriptor = avcodec_descriptor_get(avctx->codec_id);
1380
1381     if ((avctx->codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL) &&
1382         avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
1383         const char *codec_string = av_codec_is_encoder(codec) ? "encoder" : "decoder";
1384         AVCodec *codec2;
1385         av_log(avctx, AV_LOG_ERROR,
1386                "The %s '%s' is experimental but experimental codecs are not enabled, "
1387                "add '-strict %d' if you want to use it.\n",
1388                codec_string, codec->name, FF_COMPLIANCE_EXPERIMENTAL);
1389         codec2 = av_codec_is_encoder(codec) ? avcodec_find_encoder(codec->id) : avcodec_find_decoder(codec->id);
1390         if (!(codec2->capabilities & AV_CODEC_CAP_EXPERIMENTAL))
1391             av_log(avctx, AV_LOG_ERROR, "Alternatively use the non experimental %s '%s'.\n",
1392                 codec_string, codec2->name);
1393         ret = AVERROR_EXPERIMENTAL;
1394         goto free_and_end;
1395     }
1396
1397     if (avctx->codec_type == AVMEDIA_TYPE_AUDIO &&
1398         (!avctx->time_base.num || !avctx->time_base.den)) {
1399         avctx->time_base.num = 1;
1400         avctx->time_base.den = avctx->sample_rate;
1401     }
1402
1403     if (!HAVE_THREADS)
1404         av_log(avctx, AV_LOG_WARNING, "Warning: not compiled with thread support, using thread emulation\n");
1405
1406     if (CONFIG_FRAME_THREAD_ENCODER && av_codec_is_encoder(avctx->codec)) {
1407         ff_unlock_avcodec(codec); //we will instantiate a few encoders thus kick the counter to prevent false detection of a problem
1408         ret = ff_frame_thread_encoder_init(avctx, options ? *options : NULL);
1409         ff_lock_avcodec(avctx, codec);
1410         if (ret < 0)
1411             goto free_and_end;
1412     }
1413
1414     if (HAVE_THREADS
1415         && !(avctx->internal->frame_thread_encoder && (avctx->active_thread_type&FF_THREAD_FRAME))) {
1416         ret = ff_thread_init(avctx);
1417         if (ret < 0) {
1418             goto free_and_end;
1419         }
1420     }
1421     if (!HAVE_THREADS && !(codec->capabilities & AV_CODEC_CAP_AUTO_THREADS))
1422         avctx->thread_count = 1;
1423
1424     if (avctx->codec->max_lowres < avctx->lowres || avctx->lowres < 0) {
1425         av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
1426                avctx->codec->max_lowres);
1427         avctx->lowres = avctx->codec->max_lowres;
1428     }
1429
1430 #if FF_API_VISMV
1431     if (avctx->debug_mv)
1432         av_log(avctx, AV_LOG_WARNING, "The 'vismv' option is deprecated, "
1433                "see the codecview filter instead.\n");
1434 #endif
1435
1436     if (av_codec_is_encoder(avctx->codec)) {
1437         int i;
1438 #if FF_API_CODED_FRAME
1439 FF_DISABLE_DEPRECATION_WARNINGS
1440         avctx->coded_frame = av_frame_alloc();
1441         if (!avctx->coded_frame) {
1442             ret = AVERROR(ENOMEM);
1443             goto free_and_end;
1444         }
1445 FF_ENABLE_DEPRECATION_WARNINGS
1446 #endif
1447
1448         if (avctx->time_base.num <= 0 || avctx->time_base.den <= 0) {
1449             av_log(avctx, AV_LOG_ERROR, "The encoder timebase is not set.\n");
1450             ret = AVERROR(EINVAL);
1451             goto free_and_end;
1452         }
1453
1454         if (avctx->codec->sample_fmts) {
1455             for (i = 0; avctx->codec->sample_fmts[i] != AV_SAMPLE_FMT_NONE; i++) {
1456                 if (avctx->sample_fmt == avctx->codec->sample_fmts[i])
1457                     break;
1458                 if (avctx->channels == 1 &&
1459                     av_get_planar_sample_fmt(avctx->sample_fmt) ==
1460                     av_get_planar_sample_fmt(avctx->codec->sample_fmts[i])) {
1461                     avctx->sample_fmt = avctx->codec->sample_fmts[i];
1462                     break;
1463                 }
1464             }
1465             if (avctx->codec->sample_fmts[i] == AV_SAMPLE_FMT_NONE) {
1466                 char buf[128];
1467                 snprintf(buf, sizeof(buf), "%d", avctx->sample_fmt);
1468                 av_log(avctx, AV_LOG_ERROR, "Specified sample format %s is invalid or not supported\n",
1469                        (char *)av_x_if_null(av_get_sample_fmt_name(avctx->sample_fmt), buf));
1470                 ret = AVERROR(EINVAL);
1471                 goto free_and_end;
1472             }
1473         }
1474         if (avctx->codec->pix_fmts) {
1475             for (i = 0; avctx->codec->pix_fmts[i] != AV_PIX_FMT_NONE; i++)
1476                 if (avctx->pix_fmt == avctx->codec->pix_fmts[i])
1477                     break;
1478             if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_NONE
1479                 && !((avctx->codec_id == AV_CODEC_ID_MJPEG || avctx->codec_id == AV_CODEC_ID_LJPEG)
1480                      && avctx->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL)) {
1481                 char buf[128];
1482                 snprintf(buf, sizeof(buf), "%d", avctx->pix_fmt);
1483                 av_log(avctx, AV_LOG_ERROR, "Specified pixel format %s is invalid or not supported\n",
1484                        (char *)av_x_if_null(av_get_pix_fmt_name(avctx->pix_fmt), buf));
1485                 ret = AVERROR(EINVAL);
1486                 goto free_and_end;
1487             }
1488             if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ420P ||
1489                 avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ411P ||
1490                 avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ422P ||
1491                 avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ440P ||
1492                 avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ444P)
1493                 avctx->color_range = AVCOL_RANGE_JPEG;
1494         }
1495         if (avctx->codec->supported_samplerates) {
1496             for (i = 0; avctx->codec->supported_samplerates[i] != 0; i++)
1497                 if (avctx->sample_rate == avctx->codec->supported_samplerates[i])
1498                     break;
1499             if (avctx->codec->supported_samplerates[i] == 0) {
1500                 av_log(avctx, AV_LOG_ERROR, "Specified sample rate %d is not supported\n",
1501                        avctx->sample_rate);
1502                 ret = AVERROR(EINVAL);
1503                 goto free_and_end;
1504             }
1505         }
1506         if (avctx->sample_rate < 0) {
1507             av_log(avctx, AV_LOG_ERROR, "Specified sample rate %d is not supported\n",
1508                     avctx->sample_rate);
1509             ret = AVERROR(EINVAL);
1510             goto free_and_end;
1511         }
1512         if (avctx->codec->channel_layouts) {
1513             if (!avctx->channel_layout) {
1514                 av_log(avctx, AV_LOG_WARNING, "Channel layout not specified\n");
1515             } else {
1516                 for (i = 0; avctx->codec->channel_layouts[i] != 0; i++)
1517                     if (avctx->channel_layout == avctx->codec->channel_layouts[i])
1518                         break;
1519                 if (avctx->codec->channel_layouts[i] == 0) {
1520                     char buf[512];
1521                     av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
1522                     av_log(avctx, AV_LOG_ERROR, "Specified channel layout '%s' is not supported\n", buf);
1523                     ret = AVERROR(EINVAL);
1524                     goto free_and_end;
1525                 }
1526             }
1527         }
1528         if (avctx->channel_layout && avctx->channels) {
1529             int channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
1530             if (channels != avctx->channels) {
1531                 char buf[512];
1532                 av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
1533                 av_log(avctx, AV_LOG_ERROR,
1534                        "Channel layout '%s' with %d channels does not match number of specified channels %d\n",
1535                        buf, channels, avctx->channels);
1536                 ret = AVERROR(EINVAL);
1537                 goto free_and_end;
1538             }
1539         } else if (avctx->channel_layout) {
1540             avctx->channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
1541         }
1542         if (avctx->channels < 0) {
1543             av_log(avctx, AV_LOG_ERROR, "Specified number of channels %d is not supported\n",
1544                     avctx->channels);
1545             ret = AVERROR(EINVAL);
1546             goto free_and_end;
1547         }
1548         if(avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
1549             pixdesc = av_pix_fmt_desc_get(avctx->pix_fmt);
1550             if (    avctx->bits_per_raw_sample < 0
1551                 || (avctx->bits_per_raw_sample > 8 && pixdesc->comp[0].depth <= 8)) {
1552                 av_log(avctx, AV_LOG_WARNING, "Specified bit depth %d not possible with the specified pixel formats depth %d\n",
1553                     avctx->bits_per_raw_sample, pixdesc->comp[0].depth);
1554                 avctx->bits_per_raw_sample = pixdesc->comp[0].depth;
1555             }
1556             if (avctx->width <= 0 || avctx->height <= 0) {
1557                 av_log(avctx, AV_LOG_ERROR, "dimensions not set\n");
1558                 ret = AVERROR(EINVAL);
1559                 goto free_and_end;
1560             }
1561         }
1562         if (   (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO)
1563             && avctx->bit_rate>0 && avctx->bit_rate<1000) {
1564             av_log(avctx, AV_LOG_WARNING, "Bitrate %"PRId64" is extremely low, maybe you mean %"PRId64"k\n", (int64_t)avctx->bit_rate, (int64_t)avctx->bit_rate);
1565         }
1566
1567         if (!avctx->rc_initial_buffer_occupancy)
1568             avctx->rc_initial_buffer_occupancy = avctx->rc_buffer_size * 3 / 4;
1569
1570         if (avctx->ticks_per_frame && avctx->time_base.num &&
1571             avctx->ticks_per_frame > INT_MAX / avctx->time_base.num) {
1572             av_log(avctx, AV_LOG_ERROR,
1573                    "ticks_per_frame %d too large for the timebase %d/%d.",
1574                    avctx->ticks_per_frame,
1575                    avctx->time_base.num,
1576                    avctx->time_base.den);
1577             goto free_and_end;
1578         }
1579
1580         if (avctx->hw_frames_ctx) {
1581             AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
1582             if (frames_ctx->format != avctx->pix_fmt) {
1583                 av_log(avctx, AV_LOG_ERROR,
1584                        "Mismatching AVCodecContext.pix_fmt and AVHWFramesContext.format\n");
1585                 ret = AVERROR(EINVAL);
1586                 goto free_and_end;
1587             }
1588         }
1589     }
1590
1591     avctx->pts_correction_num_faulty_pts =
1592     avctx->pts_correction_num_faulty_dts = 0;
1593     avctx->pts_correction_last_pts =
1594     avctx->pts_correction_last_dts = INT64_MIN;
1595
1596     if (   !CONFIG_GRAY && avctx->flags & AV_CODEC_FLAG_GRAY
1597         && avctx->codec_descriptor->type == AVMEDIA_TYPE_VIDEO)
1598         av_log(avctx, AV_LOG_WARNING,
1599                "gray decoding requested but not enabled at configuration time\n");
1600
1601     if (   avctx->codec->init && (!(avctx->active_thread_type&FF_THREAD_FRAME)
1602         || avctx->internal->frame_thread_encoder)) {
1603         ret = avctx->codec->init(avctx);
1604         if (ret < 0) {
1605             goto free_and_end;
1606         }
1607     }
1608
1609     ret=0;
1610
1611 #if FF_API_AUDIOENC_DELAY
1612     if (av_codec_is_encoder(avctx->codec))
1613         avctx->delay = avctx->initial_padding;
1614 #endif
1615
1616     if (av_codec_is_decoder(avctx->codec)) {
1617         if (!avctx->bit_rate)
1618             avctx->bit_rate = get_bit_rate(avctx);
1619         /* validate channel layout from the decoder */
1620         if (avctx->channel_layout) {
1621             int channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
1622             if (!avctx->channels)
1623                 avctx->channels = channels;
1624             else if (channels != avctx->channels) {
1625                 char buf[512];
1626                 av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
1627                 av_log(avctx, AV_LOG_WARNING,
1628                        "Channel layout '%s' with %d channels does not match specified number of channels %d: "
1629                        "ignoring specified channel layout\n",
1630                        buf, channels, avctx->channels);
1631                 avctx->channel_layout = 0;
1632             }
1633         }
1634         if (avctx->channels && avctx->channels < 0 ||
1635             avctx->channels > FF_SANE_NB_CHANNELS) {
1636             ret = AVERROR(EINVAL);
1637             goto free_and_end;
1638         }
1639         if (avctx->sub_charenc) {
1640             if (avctx->codec_type != AVMEDIA_TYPE_SUBTITLE) {
1641                 av_log(avctx, AV_LOG_ERROR, "Character encoding is only "
1642                        "supported with subtitles codecs\n");
1643                 ret = AVERROR(EINVAL);
1644                 goto free_and_end;
1645             } else if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB) {
1646                 av_log(avctx, AV_LOG_WARNING, "Codec '%s' is bitmap-based, "
1647                        "subtitles character encoding will be ignored\n",
1648                        avctx->codec_descriptor->name);
1649                 avctx->sub_charenc_mode = FF_SUB_CHARENC_MODE_DO_NOTHING;
1650             } else {
1651                 /* input character encoding is set for a text based subtitle
1652                  * codec at this point */
1653                 if (avctx->sub_charenc_mode == FF_SUB_CHARENC_MODE_AUTOMATIC)
1654                     avctx->sub_charenc_mode = FF_SUB_CHARENC_MODE_PRE_DECODER;
1655
1656                 if (avctx->sub_charenc_mode == FF_SUB_CHARENC_MODE_PRE_DECODER) {
1657 #if CONFIG_ICONV
1658                     iconv_t cd = iconv_open("UTF-8", avctx->sub_charenc);
1659                     if (cd == (iconv_t)-1) {
1660                         ret = AVERROR(errno);
1661                         av_log(avctx, AV_LOG_ERROR, "Unable to open iconv context "
1662                                "with input character encoding \"%s\"\n", avctx->sub_charenc);
1663                         goto free_and_end;
1664                     }
1665                     iconv_close(cd);
1666 #else
1667                     av_log(avctx, AV_LOG_ERROR, "Character encoding subtitles "
1668                            "conversion needs a libavcodec built with iconv support "
1669                            "for this codec\n");
1670                     ret = AVERROR(ENOSYS);
1671                     goto free_and_end;
1672 #endif
1673                 }
1674             }
1675         }
1676
1677 #if FF_API_AVCTX_TIMEBASE
1678         if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
1679             avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));
1680 #endif
1681     }
1682     if (codec->priv_data_size > 0 && avctx->priv_data && codec->priv_class) {
1683         av_assert0(*(const AVClass **)avctx->priv_data == codec->priv_class);
1684     }
1685
1686 end:
1687     ff_unlock_avcodec(codec);
1688     if (options) {
1689         av_dict_free(options);
1690         *options = tmp;
1691     }
1692
1693     return ret;
1694 free_and_end:
1695     if (avctx->codec &&
1696         (avctx->codec->caps_internal & FF_CODEC_CAP_INIT_CLEANUP))
1697         avctx->codec->close(avctx);
1698
1699     if (codec->priv_class && codec->priv_data_size)
1700         av_opt_free(avctx->priv_data);
1701     av_opt_free(avctx);
1702
1703 #if FF_API_CODED_FRAME
1704 FF_DISABLE_DEPRECATION_WARNINGS
1705     av_frame_free(&avctx->coded_frame);
1706 FF_ENABLE_DEPRECATION_WARNINGS
1707 #endif
1708
1709     av_dict_free(&tmp);
1710     av_freep(&avctx->priv_data);
1711     if (avctx->internal) {
1712         av_packet_free(&avctx->internal->buffer_pkt);
1713         av_frame_free(&avctx->internal->buffer_frame);
1714         av_frame_free(&avctx->internal->to_free);
1715         av_freep(&avctx->internal->pool);
1716     }
1717     av_freep(&avctx->internal);
1718     avctx->codec = NULL;
1719     goto end;
1720 }
1721
1722 int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
1723 {
1724     if (avpkt->size < 0) {
1725         av_log(avctx, AV_LOG_ERROR, "Invalid negative user packet size %d\n", avpkt->size);
1726         return AVERROR(EINVAL);
1727     }
1728     if (size < 0 || size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
1729         av_log(avctx, AV_LOG_ERROR, "Invalid minimum required packet size %"PRId64" (max allowed is %d)\n",
1730                size, INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE);
1731         return AVERROR(EINVAL);
1732     }
1733
1734     if (avctx && 2*min_size < size) { // FIXME The factor needs to be finetuned
1735         av_assert0(!avpkt->data || avpkt->data != avctx->internal->byte_buffer);
1736         if (!avpkt->data || avpkt->size < size) {
1737             av_fast_padded_malloc(&avctx->internal->byte_buffer, &avctx->internal->byte_buffer_size, size);
1738             avpkt->data = avctx->internal->byte_buffer;
1739             avpkt->size = avctx->internal->byte_buffer_size;
1740         }
1741     }
1742
1743     if (avpkt->data) {
1744         AVBufferRef *buf = avpkt->buf;
1745
1746         if (avpkt->size < size) {
1747             av_log(avctx, AV_LOG_ERROR, "User packet is too small (%d < %"PRId64")\n", avpkt->size, size);
1748             return AVERROR(EINVAL);
1749         }
1750
1751         av_init_packet(avpkt);
1752         avpkt->buf      = buf;
1753         avpkt->size     = size;
1754         return 0;
1755     } else {
1756         int ret = av_new_packet(avpkt, size);
1757         if (ret < 0)
1758             av_log(avctx, AV_LOG_ERROR, "Failed to allocate packet of size %"PRId64"\n", size);
1759         return ret;
1760     }
1761 }
1762
1763 int ff_alloc_packet(AVPacket *avpkt, int size)
1764 {
1765     return ff_alloc_packet2(NULL, avpkt, size, 0);
1766 }
1767
1768 /**
1769  * Pad last frame with silence.
1770  */
1771 static int pad_last_frame(AVCodecContext *s, AVFrame **dst, const AVFrame *src)
1772 {
1773     AVFrame *frame = NULL;
1774     int ret;
1775
1776     if (!(frame = av_frame_alloc()))
1777         return AVERROR(ENOMEM);
1778
1779     frame->format         = src->format;
1780     frame->channel_layout = src->channel_layout;
1781     av_frame_set_channels(frame, av_frame_get_channels(src));
1782     frame->nb_samples     = s->frame_size;
1783     ret = av_frame_get_buffer(frame, 32);
1784     if (ret < 0)
1785         goto fail;
1786
1787     ret = av_frame_copy_props(frame, src);
1788     if (ret < 0)
1789         goto fail;
1790
1791     if ((ret = av_samples_copy(frame->extended_data, src->extended_data, 0, 0,
1792                                src->nb_samples, s->channels, s->sample_fmt)) < 0)
1793         goto fail;
1794     if ((ret = av_samples_set_silence(frame->extended_data, src->nb_samples,
1795                                       frame->nb_samples - src->nb_samples,
1796                                       s->channels, s->sample_fmt)) < 0)
1797         goto fail;
1798
1799     *dst = frame;
1800
1801     return 0;
1802
1803 fail:
1804     av_frame_free(&frame);
1805     return ret;
1806 }
1807
1808 int attribute_align_arg avcodec_encode_audio2(AVCodecContext *avctx,
1809                                               AVPacket *avpkt,
1810                                               const AVFrame *frame,
1811                                               int *got_packet_ptr)
1812 {
1813     AVFrame *extended_frame = NULL;
1814     AVFrame *padded_frame = NULL;
1815     int ret;
1816     AVPacket user_pkt = *avpkt;
1817     int needs_realloc = !user_pkt.data;
1818
1819     *got_packet_ptr = 0;
1820
1821     if (!avctx->codec->encode2) {
1822         av_log(avctx, AV_LOG_ERROR, "This encoder requires using the avcodec_send_frame() API.\n");
1823         return AVERROR(ENOSYS);
1824     }
1825
1826     if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY) && !frame) {
1827         av_packet_unref(avpkt);
1828         av_init_packet(avpkt);
1829         return 0;
1830     }
1831
1832     /* ensure that extended_data is properly set */
1833     if (frame && !frame->extended_data) {
1834         if (av_sample_fmt_is_planar(avctx->sample_fmt) &&
1835             avctx->channels > AV_NUM_DATA_POINTERS) {
1836             av_log(avctx, AV_LOG_ERROR, "Encoding to a planar sample format, "
1837                                         "with more than %d channels, but extended_data is not set.\n",
1838                    AV_NUM_DATA_POINTERS);
1839             return AVERROR(EINVAL);
1840         }
1841         av_log(avctx, AV_LOG_WARNING, "extended_data is not set.\n");
1842
1843         extended_frame = av_frame_alloc();
1844         if (!extended_frame)
1845             return AVERROR(ENOMEM);
1846
1847         memcpy(extended_frame, frame, sizeof(AVFrame));
1848         extended_frame->extended_data = extended_frame->data;
1849         frame = extended_frame;
1850     }
1851
1852     /* extract audio service type metadata */
1853     if (frame) {
1854         AVFrameSideData *sd = av_frame_get_side_data(frame, AV_FRAME_DATA_AUDIO_SERVICE_TYPE);
1855         if (sd && sd->size >= sizeof(enum AVAudioServiceType))
1856             avctx->audio_service_type = *(enum AVAudioServiceType*)sd->data;
1857     }
1858
1859     /* check for valid frame size */
1860     if (frame) {
1861         if (avctx->codec->capabilities & AV_CODEC_CAP_SMALL_LAST_FRAME) {
1862             if (frame->nb_samples > avctx->frame_size) {
1863                 av_log(avctx, AV_LOG_ERROR, "more samples than frame size (avcodec_encode_audio2)\n");
1864                 ret = AVERROR(EINVAL);
1865                 goto end;
1866             }
1867         } else if (!(avctx->codec->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE)) {
1868             if (frame->nb_samples < avctx->frame_size &&
1869                 !avctx->internal->last_audio_frame) {
1870                 ret = pad_last_frame(avctx, &padded_frame, frame);
1871                 if (ret < 0)
1872                     goto end;
1873
1874                 frame = padded_frame;
1875                 avctx->internal->last_audio_frame = 1;
1876             }
1877
1878             if (frame->nb_samples != avctx->frame_size) {
1879                 av_log(avctx, AV_LOG_ERROR, "nb_samples (%d) != frame_size (%d) (avcodec_encode_audio2)\n", frame->nb_samples, avctx->frame_size);
1880                 ret = AVERROR(EINVAL);
1881                 goto end;
1882             }
1883         }
1884     }
1885
1886     av_assert0(avctx->codec->encode2);
1887
1888     ret = avctx->codec->encode2(avctx, avpkt, frame, got_packet_ptr);
1889     if (!ret) {
1890         if (*got_packet_ptr) {
1891             if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY)) {
1892                 if (avpkt->pts == AV_NOPTS_VALUE)
1893                     avpkt->pts = frame->pts;
1894                 if (!avpkt->duration)
1895                     avpkt->duration = ff_samples_to_time_base(avctx,
1896                                                               frame->nb_samples);
1897             }
1898             avpkt->dts = avpkt->pts;
1899         } else {
1900             avpkt->size = 0;
1901         }
1902     }
1903     if (avpkt->data && avpkt->data == avctx->internal->byte_buffer) {
1904         needs_realloc = 0;
1905         if (user_pkt.data) {
1906             if (user_pkt.size >= avpkt->size) {
1907                 memcpy(user_pkt.data, avpkt->data, avpkt->size);
1908             } else {
1909                 av_log(avctx, AV_LOG_ERROR, "Provided packet is too small, needs to be %d\n", avpkt->size);
1910                 avpkt->size = user_pkt.size;
1911                 ret = -1;
1912             }
1913             avpkt->buf      = user_pkt.buf;
1914             avpkt->data     = user_pkt.data;
1915         } else {
1916             if (av_dup_packet(avpkt) < 0) {
1917                 ret = AVERROR(ENOMEM);
1918             }
1919         }
1920     }
1921
1922     if (!ret) {
1923         if (needs_realloc && avpkt->data) {
1924             ret = av_buffer_realloc(&avpkt->buf, avpkt->size + AV_INPUT_BUFFER_PADDING_SIZE);
1925             if (ret >= 0)
1926                 avpkt->data = avpkt->buf->data;
1927         }
1928
1929         avctx->frame_number++;
1930     }
1931
1932     if (ret < 0 || !*got_packet_ptr) {
1933         av_packet_unref(avpkt);
1934         av_init_packet(avpkt);
1935         goto end;
1936     }
1937
1938     /* NOTE: if we add any audio encoders which output non-keyframe packets,
1939      *       this needs to be moved to the encoders, but for now we can do it
1940      *       here to simplify things */
1941     avpkt->flags |= AV_PKT_FLAG_KEY;
1942
1943 end:
1944     av_frame_free(&padded_frame);
1945     av_free(extended_frame);
1946
1947 #if FF_API_AUDIOENC_DELAY
1948     avctx->delay = avctx->initial_padding;
1949 #endif
1950
1951     return ret;
1952 }
1953
1954 int attribute_align_arg avcodec_encode_video2(AVCodecContext *avctx,
1955                                               AVPacket *avpkt,
1956                                               const AVFrame *frame,
1957                                               int *got_packet_ptr)
1958 {
1959     int ret;
1960     AVPacket user_pkt = *avpkt;
1961     int needs_realloc = !user_pkt.data;
1962
1963     *got_packet_ptr = 0;
1964
1965     if (!avctx->codec->encode2) {
1966         av_log(avctx, AV_LOG_ERROR, "This encoder requires using the avcodec_send_frame() API.\n");
1967         return AVERROR(ENOSYS);
1968     }
1969
1970     if(CONFIG_FRAME_THREAD_ENCODER &&
1971        avctx->internal->frame_thread_encoder && (avctx->active_thread_type&FF_THREAD_FRAME))
1972         return ff_thread_video_encode_frame(avctx, avpkt, frame, got_packet_ptr);
1973
1974     if ((avctx->flags&AV_CODEC_FLAG_PASS1) && avctx->stats_out)
1975         avctx->stats_out[0] = '\0';
1976
1977     if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY) && !frame) {
1978         av_packet_unref(avpkt);
1979         av_init_packet(avpkt);
1980         avpkt->size = 0;
1981         return 0;
1982     }
1983
1984     if (av_image_check_size(avctx->width, avctx->height, 0, avctx))
1985         return AVERROR(EINVAL);
1986
1987     if (frame && frame->format == AV_PIX_FMT_NONE)
1988         av_log(avctx, AV_LOG_WARNING, "AVFrame.format is not set\n");
1989     if (frame && (frame->width == 0 || frame->height == 0))
1990         av_log(avctx, AV_LOG_WARNING, "AVFrame.width or height is not set\n");
1991
1992     av_assert0(avctx->codec->encode2);
1993
1994     ret = avctx->codec->encode2(avctx, avpkt, frame, got_packet_ptr);
1995     av_assert0(ret <= 0);
1996
1997     emms_c();
1998
1999     if (avpkt->data && avpkt->data == avctx->internal->byte_buffer) {
2000         needs_realloc = 0;
2001         if (user_pkt.data) {
2002             if (user_pkt.size >= avpkt->size) {
2003                 memcpy(user_pkt.data, avpkt->data, avpkt->size);
2004             } else {
2005                 av_log(avctx, AV_LOG_ERROR, "Provided packet is too small, needs to be %d\n", avpkt->size);
2006                 avpkt->size = user_pkt.size;
2007                 ret = -1;
2008             }
2009             avpkt->buf      = user_pkt.buf;
2010             avpkt->data     = user_pkt.data;
2011         } else {
2012             if (av_dup_packet(avpkt) < 0) {
2013                 ret = AVERROR(ENOMEM);
2014             }
2015         }
2016     }
2017
2018     if (!ret) {
2019         if (!*got_packet_ptr)
2020             avpkt->size = 0;
2021         else if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY))
2022             avpkt->pts = avpkt->dts = frame->pts;
2023
2024         if (needs_realloc && avpkt->data) {
2025             ret = av_buffer_realloc(&avpkt->buf, avpkt->size + AV_INPUT_BUFFER_PADDING_SIZE);
2026             if (ret >= 0)
2027                 avpkt->data = avpkt->buf->data;
2028         }
2029
2030         avctx->frame_number++;
2031     }
2032
2033     if (ret < 0 || !*got_packet_ptr)
2034         av_packet_unref(avpkt);
2035
2036     return ret;
2037 }
2038
2039 int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size,
2040                             const AVSubtitle *sub)
2041 {
2042     int ret;
2043     if (sub->start_display_time) {
2044         av_log(avctx, AV_LOG_ERROR, "start_display_time must be 0.\n");
2045         return -1;
2046     }
2047
2048     ret = avctx->codec->encode_sub(avctx, buf, buf_size, sub);
2049     avctx->frame_number++;
2050     return ret;
2051 }
2052
2053 /**
2054  * Attempt to guess proper monotonic timestamps for decoded video frames
2055  * which might have incorrect times. Input timestamps may wrap around, in
2056  * which case the output will as well.
2057  *
2058  * @param pts the pts field of the decoded AVPacket, as passed through
2059  * AVFrame.pts
2060  * @param dts the dts field of the decoded AVPacket
2061  * @return one of the input values, may be AV_NOPTS_VALUE
2062  */
2063 static int64_t guess_correct_pts(AVCodecContext *ctx,
2064                                  int64_t reordered_pts, int64_t dts)
2065 {
2066     int64_t pts = AV_NOPTS_VALUE;
2067
2068     if (dts != AV_NOPTS_VALUE) {
2069         ctx->pts_correction_num_faulty_dts += dts <= ctx->pts_correction_last_dts;
2070         ctx->pts_correction_last_dts = dts;
2071     } else if (reordered_pts != AV_NOPTS_VALUE)
2072         ctx->pts_correction_last_dts = reordered_pts;
2073
2074     if (reordered_pts != AV_NOPTS_VALUE) {
2075         ctx->pts_correction_num_faulty_pts += reordered_pts <= ctx->pts_correction_last_pts;
2076         ctx->pts_correction_last_pts = reordered_pts;
2077     } else if(dts != AV_NOPTS_VALUE)
2078         ctx->pts_correction_last_pts = dts;
2079
2080     if ((ctx->pts_correction_num_faulty_pts<=ctx->pts_correction_num_faulty_dts || dts == AV_NOPTS_VALUE)
2081        && reordered_pts != AV_NOPTS_VALUE)
2082         pts = reordered_pts;
2083     else
2084         pts = dts;
2085
2086     return pts;
2087 }
2088
2089 static int apply_param_change(AVCodecContext *avctx, AVPacket *avpkt)
2090 {
2091     int size = 0, ret;
2092     const uint8_t *data;
2093     uint32_t flags;
2094     int64_t val;
2095
2096     data = av_packet_get_side_data(avpkt, AV_PKT_DATA_PARAM_CHANGE, &size);
2097     if (!data)
2098         return 0;
2099
2100     if (!(avctx->codec->capabilities & AV_CODEC_CAP_PARAM_CHANGE)) {
2101         av_log(avctx, AV_LOG_ERROR, "This decoder does not support parameter "
2102                "changes, but PARAM_CHANGE side data was sent to it.\n");
2103         ret = AVERROR(EINVAL);
2104         goto fail2;
2105     }
2106
2107     if (size < 4)
2108         goto fail;
2109
2110     flags = bytestream_get_le32(&data);
2111     size -= 4;
2112
2113     if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT) {
2114         if (size < 4)
2115             goto fail;
2116         val = bytestream_get_le32(&data);
2117         if (val <= 0 || val > INT_MAX) {
2118             av_log(avctx, AV_LOG_ERROR, "Invalid channel count");
2119             ret = AVERROR_INVALIDDATA;
2120             goto fail2;
2121         }
2122         avctx->channels = val;
2123         size -= 4;
2124     }
2125     if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT) {
2126         if (size < 8)
2127             goto fail;
2128         avctx->channel_layout = bytestream_get_le64(&data);
2129         size -= 8;
2130     }
2131     if (flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE) {
2132         if (size < 4)
2133             goto fail;
2134         val = bytestream_get_le32(&data);
2135         if (val <= 0 || val > INT_MAX) {
2136             av_log(avctx, AV_LOG_ERROR, "Invalid sample rate");
2137             ret = AVERROR_INVALIDDATA;
2138             goto fail2;
2139         }
2140         avctx->sample_rate = val;
2141         size -= 4;
2142     }
2143     if (flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS) {
2144         if (size < 8)
2145             goto fail;
2146         avctx->width  = bytestream_get_le32(&data);
2147         avctx->height = bytestream_get_le32(&data);
2148         size -= 8;
2149         ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
2150         if (ret < 0)
2151             goto fail2;
2152     }
2153
2154     return 0;
2155 fail:
2156     av_log(avctx, AV_LOG_ERROR, "PARAM_CHANGE side data too small.\n");
2157     ret = AVERROR_INVALIDDATA;
2158 fail2:
2159     if (ret < 0) {
2160         av_log(avctx, AV_LOG_ERROR, "Error applying parameter changes.\n");
2161         if (avctx->err_recognition & AV_EF_EXPLODE)
2162             return ret;
2163     }
2164     return 0;
2165 }
2166
2167 static int unrefcount_frame(AVCodecInternal *avci, AVFrame *frame)
2168 {
2169     int ret;
2170
2171     /* move the original frame to our backup */
2172     av_frame_unref(avci->to_free);
2173     av_frame_move_ref(avci->to_free, frame);
2174
2175     /* now copy everything except the AVBufferRefs back
2176      * note that we make a COPY of the side data, so calling av_frame_free() on
2177      * the caller's frame will work properly */
2178     ret = av_frame_copy_props(frame, avci->to_free);
2179     if (ret < 0)
2180         return ret;
2181
2182     memcpy(frame->data,     avci->to_free->data,     sizeof(frame->data));
2183     memcpy(frame->linesize, avci->to_free->linesize, sizeof(frame->linesize));
2184     if (avci->to_free->extended_data != avci->to_free->data) {
2185         int planes = av_frame_get_channels(avci->to_free);
2186         int size   = planes * sizeof(*frame->extended_data);
2187
2188         if (!size) {
2189             av_frame_unref(frame);
2190             return AVERROR_BUG;
2191         }
2192
2193         frame->extended_data = av_malloc(size);
2194         if (!frame->extended_data) {
2195             av_frame_unref(frame);
2196             return AVERROR(ENOMEM);
2197         }
2198         memcpy(frame->extended_data, avci->to_free->extended_data,
2199                size);
2200     } else
2201         frame->extended_data = frame->data;
2202
2203     frame->format         = avci->to_free->format;
2204     frame->width          = avci->to_free->width;
2205     frame->height         = avci->to_free->height;
2206     frame->channel_layout = avci->to_free->channel_layout;
2207     frame->nb_samples     = avci->to_free->nb_samples;
2208     av_frame_set_channels(frame, av_frame_get_channels(avci->to_free));
2209
2210     return 0;
2211 }
2212
2213 int attribute_align_arg avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
2214                                               int *got_picture_ptr,
2215                                               const AVPacket *avpkt)
2216 {
2217     AVCodecInternal *avci = avctx->internal;
2218     int ret;
2219     // copy to ensure we do not change avpkt
2220     AVPacket tmp = *avpkt;
2221
2222     if (!avctx->codec)
2223         return AVERROR(EINVAL);
2224     if (avctx->codec->type != AVMEDIA_TYPE_VIDEO) {
2225         av_log(avctx, AV_LOG_ERROR, "Invalid media type for video\n");
2226         return AVERROR(EINVAL);
2227     }
2228
2229     if (!avctx->codec->decode) {
2230         av_log(avctx, AV_LOG_ERROR, "This decoder requires using the avcodec_send_packet() API.\n");
2231         return AVERROR(ENOSYS);
2232     }
2233
2234     *got_picture_ptr = 0;
2235     if ((avctx->coded_width || avctx->coded_height) && av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx))
2236         return AVERROR(EINVAL);
2237
2238     avctx->internal->pkt = avpkt;
2239     ret = apply_param_change(avctx, avpkt);
2240     if (ret < 0)
2241         return ret;
2242
2243     av_frame_unref(picture);
2244
2245     if ((avctx->codec->capabilities & AV_CODEC_CAP_DELAY) || avpkt->size ||
2246         (avctx->active_thread_type & FF_THREAD_FRAME)) {
2247         int did_split = av_packet_split_side_data(&tmp);
2248         ret = apply_param_change(avctx, &tmp);
2249         if (ret < 0)
2250             goto fail;
2251
2252         avctx->internal->pkt = &tmp;
2253         if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME)
2254             ret = ff_thread_decode_frame(avctx, picture, got_picture_ptr,
2255                                          &tmp);
2256         else {
2257             ret = avctx->codec->decode(avctx, picture, got_picture_ptr,
2258                                        &tmp);
2259             if (!(avctx->codec->caps_internal & FF_CODEC_CAP_SETS_PKT_DTS))
2260                 picture->pkt_dts = avpkt->dts;
2261
2262             if(!avctx->has_b_frames){
2263                 av_frame_set_pkt_pos(picture, avpkt->pos);
2264             }
2265             //FIXME these should be under if(!avctx->has_b_frames)
2266             /* get_buffer is supposed to set frame parameters */
2267             if (!(avctx->codec->capabilities & AV_CODEC_CAP_DR1)) {
2268                 if (!picture->sample_aspect_ratio.num)    picture->sample_aspect_ratio = avctx->sample_aspect_ratio;
2269                 if (!picture->width)                      picture->width               = avctx->width;
2270                 if (!picture->height)                     picture->height              = avctx->height;
2271                 if (picture->format == AV_PIX_FMT_NONE)   picture->format              = avctx->pix_fmt;
2272             }
2273         }
2274
2275 fail:
2276         emms_c(); //needed to avoid an emms_c() call before every return;
2277
2278         avctx->internal->pkt = NULL;
2279         if (did_split) {
2280             av_packet_free_side_data(&tmp);
2281             if(ret == tmp.size)
2282                 ret = avpkt->size;
2283         }
2284         if (picture->flags & AV_FRAME_FLAG_DISCARD) {
2285             *got_picture_ptr = 0;
2286         }
2287         if (*got_picture_ptr) {
2288             if (!avctx->refcounted_frames) {
2289                 int err = unrefcount_frame(avci, picture);
2290                 if (err < 0)
2291                     return err;
2292             }
2293
2294             avctx->frame_number++;
2295             av_frame_set_best_effort_timestamp(picture,
2296                                                guess_correct_pts(avctx,
2297                                                                  picture->pts,
2298                                                                  picture->pkt_dts));
2299         } else
2300             av_frame_unref(picture);
2301     } else
2302         ret = 0;
2303
2304     /* many decoders assign whole AVFrames, thus overwriting extended_data;
2305      * make sure it's set correctly */
2306     av_assert0(!picture->extended_data || picture->extended_data == picture->data);
2307
2308 #if FF_API_AVCTX_TIMEBASE
2309     if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
2310         avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));
2311 #endif
2312
2313     return ret;
2314 }
2315
2316 int attribute_align_arg avcodec_decode_audio4(AVCodecContext *avctx,
2317                                               AVFrame *frame,
2318                                               int *got_frame_ptr,
2319                                               const AVPacket *avpkt)
2320 {
2321     AVCodecInternal *avci = avctx->internal;
2322     int ret = 0;
2323
2324     *got_frame_ptr = 0;
2325
2326     if (!avctx->codec)
2327         return AVERROR(EINVAL);
2328
2329     if (!avctx->codec->decode) {
2330         av_log(avctx, AV_LOG_ERROR, "This decoder requires using the avcodec_send_packet() API.\n");
2331         return AVERROR(ENOSYS);
2332     }
2333
2334     if (!avpkt->data && avpkt->size) {
2335         av_log(avctx, AV_LOG_ERROR, "invalid packet: NULL data, size != 0\n");
2336         return AVERROR(EINVAL);
2337     }
2338     if (avctx->codec->type != AVMEDIA_TYPE_AUDIO) {
2339         av_log(avctx, AV_LOG_ERROR, "Invalid media type for audio\n");
2340         return AVERROR(EINVAL);
2341     }
2342
2343     av_frame_unref(frame);
2344
2345     if ((avctx->codec->capabilities & AV_CODEC_CAP_DELAY) || avpkt->size || (avctx->active_thread_type & FF_THREAD_FRAME)) {
2346         uint8_t *side;
2347         int side_size;
2348         uint32_t discard_padding = 0;
2349         uint8_t skip_reason = 0;
2350         uint8_t discard_reason = 0;
2351         // copy to ensure we do not change avpkt
2352         AVPacket tmp = *avpkt;
2353         int did_split = av_packet_split_side_data(&tmp);
2354         ret = apply_param_change(avctx, &tmp);
2355         if (ret < 0)
2356             goto fail;
2357
2358         avctx->internal->pkt = &tmp;
2359         if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME)
2360             ret = ff_thread_decode_frame(avctx, frame, got_frame_ptr, &tmp);
2361         else {
2362             ret = avctx->codec->decode(avctx, frame, got_frame_ptr, &tmp);
2363             av_assert0(ret <= tmp.size);
2364             frame->pkt_dts = avpkt->dts;
2365         }
2366         if (ret >= 0 && *got_frame_ptr) {
2367             avctx->frame_number++;
2368             av_frame_set_best_effort_timestamp(frame,
2369                                                guess_correct_pts(avctx,
2370                                                                  frame->pts,
2371                                                                  frame->pkt_dts));
2372             if (frame->format == AV_SAMPLE_FMT_NONE)
2373                 frame->format = avctx->sample_fmt;
2374             if (!frame->channel_layout)
2375                 frame->channel_layout = avctx->channel_layout;
2376             if (!av_frame_get_channels(frame))
2377                 av_frame_set_channels(frame, avctx->channels);
2378             if (!frame->sample_rate)
2379                 frame->sample_rate = avctx->sample_rate;
2380         }
2381
2382         side= av_packet_get_side_data(avctx->internal->pkt, AV_PKT_DATA_SKIP_SAMPLES, &side_size);
2383         if(side && side_size>=10) {
2384             avctx->internal->skip_samples = AV_RL32(side);
2385             discard_padding = AV_RL32(side + 4);
2386             av_log(avctx, AV_LOG_DEBUG, "skip %d / discard %d samples due to side data\n",
2387                    avctx->internal->skip_samples, (int)discard_padding);
2388             skip_reason = AV_RL8(side + 8);
2389             discard_reason = AV_RL8(side + 9);
2390         }
2391
2392         if ((frame->flags & AV_FRAME_FLAG_DISCARD) && *got_frame_ptr &&
2393             !(avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
2394             avctx->internal->skip_samples -= frame->nb_samples;
2395             *got_frame_ptr = 0;
2396         }
2397
2398         if (avctx->internal->skip_samples > 0 && *got_frame_ptr &&
2399             !(avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
2400             if(frame->nb_samples <= avctx->internal->skip_samples){
2401                 *got_frame_ptr = 0;
2402                 avctx->internal->skip_samples -= frame->nb_samples;
2403                 av_log(avctx, AV_LOG_DEBUG, "skip whole frame, skip left: %d\n",
2404                        avctx->internal->skip_samples);
2405             } else {
2406                 av_samples_copy(frame->extended_data, frame->extended_data, 0, avctx->internal->skip_samples,
2407                                 frame->nb_samples - avctx->internal->skip_samples, avctx->channels, frame->format);
2408                 if(avctx->pkt_timebase.num && avctx->sample_rate) {
2409                     int64_t diff_ts = av_rescale_q(avctx->internal->skip_samples,
2410                                                    (AVRational){1, avctx->sample_rate},
2411                                                    avctx->pkt_timebase);
2412                     if(frame->pts!=AV_NOPTS_VALUE)
2413                         frame->pts += diff_ts;
2414 #if FF_API_PKT_PTS
2415 FF_DISABLE_DEPRECATION_WARNINGS
2416                     if(frame->pkt_pts!=AV_NOPTS_VALUE)
2417                         frame->pkt_pts += diff_ts;
2418 FF_ENABLE_DEPRECATION_WARNINGS
2419 #endif
2420                     if(frame->pkt_dts!=AV_NOPTS_VALUE)
2421                         frame->pkt_dts += diff_ts;
2422                     if (av_frame_get_pkt_duration(frame) >= diff_ts)
2423                         av_frame_set_pkt_duration(frame, av_frame_get_pkt_duration(frame) - diff_ts);
2424                 } else {
2425                     av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for skipped samples.\n");
2426                 }
2427                 av_log(avctx, AV_LOG_DEBUG, "skip %d/%d samples\n",
2428                        avctx->internal->skip_samples, frame->nb_samples);
2429                 frame->nb_samples -= avctx->internal->skip_samples;
2430                 avctx->internal->skip_samples = 0;
2431             }
2432         }
2433
2434         if (discard_padding > 0 && discard_padding <= frame->nb_samples && *got_frame_ptr &&
2435             !(avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
2436             if (discard_padding == frame->nb_samples) {
2437                 *got_frame_ptr = 0;
2438             } else {
2439                 if(avctx->pkt_timebase.num && avctx->sample_rate) {
2440                     int64_t diff_ts = av_rescale_q(frame->nb_samples - discard_padding,
2441                                                    (AVRational){1, avctx->sample_rate},
2442                                                    avctx->pkt_timebase);
2443                     av_frame_set_pkt_duration(frame, diff_ts);
2444                 } else {
2445                     av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for discarded samples.\n");
2446                 }
2447                 av_log(avctx, AV_LOG_DEBUG, "discard %d/%d samples\n",
2448                        (int)discard_padding, frame->nb_samples);
2449                 frame->nb_samples -= discard_padding;
2450             }
2451         }
2452
2453         if ((avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL) && *got_frame_ptr) {
2454             AVFrameSideData *fside = av_frame_new_side_data(frame, AV_FRAME_DATA_SKIP_SAMPLES, 10);
2455             if (fside) {
2456                 AV_WL32(fside->data, avctx->internal->skip_samples);
2457                 AV_WL32(fside->data + 4, discard_padding);
2458                 AV_WL8(fside->data + 8, skip_reason);
2459                 AV_WL8(fside->data + 9, discard_reason);
2460                 avctx->internal->skip_samples = 0;
2461             }
2462         }
2463 fail:
2464         avctx->internal->pkt = NULL;
2465         if (did_split) {
2466             av_packet_free_side_data(&tmp);
2467             if(ret == tmp.size)
2468                 ret = avpkt->size;
2469         }
2470
2471         if (ret >= 0 && *got_frame_ptr) {
2472             if (!avctx->refcounted_frames) {
2473                 int err = unrefcount_frame(avci, frame);
2474                 if (err < 0)
2475                     return err;
2476             }
2477         } else
2478             av_frame_unref(frame);
2479     }
2480
2481     av_assert0(ret <= avpkt->size);
2482
2483     if (!avci->showed_multi_packet_warning &&
2484         ret >= 0 && ret != avpkt->size && !(avctx->codec->capabilities & AV_CODEC_CAP_SUBFRAMES)) {
2485             av_log(avctx, AV_LOG_WARNING, "Multiple frames in a packet.\n");
2486         avci->showed_multi_packet_warning = 1;
2487     }
2488
2489     return ret;
2490 }
2491
2492 #define UTF8_MAX_BYTES 4 /* 5 and 6 bytes sequences should not be used */
2493 static int recode_subtitle(AVCodecContext *avctx,
2494                            AVPacket *outpkt, const AVPacket *inpkt)
2495 {
2496 #if CONFIG_ICONV
2497     iconv_t cd = (iconv_t)-1;
2498     int ret = 0;
2499     char *inb, *outb;
2500     size_t inl, outl;
2501     AVPacket tmp;
2502 #endif
2503
2504     if (avctx->sub_charenc_mode != FF_SUB_CHARENC_MODE_PRE_DECODER || inpkt->size == 0)
2505         return 0;
2506
2507 #if CONFIG_ICONV
2508     cd = iconv_open("UTF-8", avctx->sub_charenc);
2509     av_assert0(cd != (iconv_t)-1);
2510
2511     inb = inpkt->data;
2512     inl = inpkt->size;
2513
2514     if (inl >= INT_MAX / UTF8_MAX_BYTES - AV_INPUT_BUFFER_PADDING_SIZE) {
2515         av_log(avctx, AV_LOG_ERROR, "Subtitles packet is too big for recoding\n");
2516         ret = AVERROR(ENOMEM);
2517         goto end;
2518     }
2519
2520     ret = av_new_packet(&tmp, inl * UTF8_MAX_BYTES);
2521     if (ret < 0)
2522         goto end;
2523     outpkt->buf  = tmp.buf;
2524     outpkt->data = tmp.data;
2525     outpkt->size = tmp.size;
2526     outb = outpkt->data;
2527     outl = outpkt->size;
2528
2529     if (iconv(cd, &inb, &inl, &outb, &outl) == (size_t)-1 ||
2530         iconv(cd, NULL, NULL, &outb, &outl) == (size_t)-1 ||
2531         outl >= outpkt->size || inl != 0) {
2532         ret = FFMIN(AVERROR(errno), -1);
2533         av_log(avctx, AV_LOG_ERROR, "Unable to recode subtitle event \"%s\" "
2534                "from %s to UTF-8\n", inpkt->data, avctx->sub_charenc);
2535         av_packet_unref(&tmp);
2536         goto end;
2537     }
2538     outpkt->size -= outl;
2539     memset(outpkt->data + outpkt->size, 0, outl);
2540
2541 end:
2542     if (cd != (iconv_t)-1)
2543         iconv_close(cd);
2544     return ret;
2545 #else
2546     av_log(avctx, AV_LOG_ERROR, "requesting subtitles recoding without iconv");
2547     return AVERROR(EINVAL);
2548 #endif
2549 }
2550
2551 static int utf8_check(const uint8_t *str)
2552 {
2553     const uint8_t *byte;
2554     uint32_t codepoint, min;
2555
2556     while (*str) {
2557         byte = str;
2558         GET_UTF8(codepoint, *(byte++), return 0;);
2559         min = byte - str == 1 ? 0 : byte - str == 2 ? 0x80 :
2560               1 << (5 * (byte - str) - 4);
2561         if (codepoint < min || codepoint >= 0x110000 ||
2562             codepoint == 0xFFFE /* BOM */ ||
2563             codepoint >= 0xD800 && codepoint <= 0xDFFF /* surrogates */)
2564             return 0;
2565         str = byte;
2566     }
2567     return 1;
2568 }
2569
2570 #if FF_API_ASS_TIMING
2571 static void insert_ts(AVBPrint *buf, int ts)
2572 {
2573     if (ts == -1) {
2574         av_bprintf(buf, "9:59:59.99,");
2575     } else {
2576         int h, m, s;
2577
2578         h = ts/360000;  ts -= 360000*h;
2579         m = ts/  6000;  ts -=   6000*m;
2580         s = ts/   100;  ts -=    100*s;
2581         av_bprintf(buf, "%d:%02d:%02d.%02d,", h, m, s, ts);
2582     }
2583 }
2584
2585 static int convert_sub_to_old_ass_form(AVSubtitle *sub, const AVPacket *pkt, AVRational tb)
2586 {
2587     int i;
2588     AVBPrint buf;
2589
2590     av_bprint_init(&buf, 0, AV_BPRINT_SIZE_UNLIMITED);
2591
2592     for (i = 0; i < sub->num_rects; i++) {
2593         char *final_dialog;
2594         const char *dialog;
2595         AVSubtitleRect *rect = sub->rects[i];
2596         int ts_start, ts_duration = -1;
2597         long int layer;
2598
2599         if (rect->type != SUBTITLE_ASS || !strncmp(rect->ass, "Dialogue: ", 10))
2600             continue;
2601
2602         av_bprint_clear(&buf);
2603
2604         /* skip ReadOrder */
2605         dialog = strchr(rect->ass, ',');
2606         if (!dialog)
2607             continue;
2608         dialog++;
2609
2610         /* extract Layer or Marked */
2611         layer = strtol(dialog, (char**)&dialog, 10);
2612         if (*dialog != ',')
2613             continue;
2614         dialog++;
2615
2616         /* rescale timing to ASS time base (ms) */
2617         ts_start = av_rescale_q(pkt->pts, tb, av_make_q(1, 100));
2618         if (pkt->duration != -1)
2619             ts_duration = av_rescale_q(pkt->duration, tb, av_make_q(1, 100));
2620         sub->end_display_time = FFMAX(sub->end_display_time, 10 * ts_duration);
2621
2622         /* construct ASS (standalone file form with timestamps) string */
2623         av_bprintf(&buf, "Dialogue: %ld,", layer);
2624         insert_ts(&buf, ts_start);
2625         insert_ts(&buf, ts_duration == -1 ? -1 : ts_start + ts_duration);
2626         av_bprintf(&buf, "%s\r\n", dialog);
2627
2628         final_dialog = av_strdup(buf.str);
2629         if (!av_bprint_is_complete(&buf) || !final_dialog) {
2630             av_freep(&final_dialog);
2631             av_bprint_finalize(&buf, NULL);
2632             return AVERROR(ENOMEM);
2633         }
2634         av_freep(&rect->ass);
2635         rect->ass = final_dialog;
2636     }
2637
2638     av_bprint_finalize(&buf, NULL);
2639     return 0;
2640 }
2641 #endif
2642
2643 int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub,
2644                              int *got_sub_ptr,
2645                              AVPacket *avpkt)
2646 {
2647     int i, ret = 0;
2648
2649     if (!avpkt->data && avpkt->size) {
2650         av_log(avctx, AV_LOG_ERROR, "invalid packet: NULL data, size != 0\n");
2651         return AVERROR(EINVAL);
2652     }
2653     if (!avctx->codec)
2654         return AVERROR(EINVAL);
2655     if (avctx->codec->type != AVMEDIA_TYPE_SUBTITLE) {
2656         av_log(avctx, AV_LOG_ERROR, "Invalid media type for subtitles\n");
2657         return AVERROR(EINVAL);
2658     }
2659
2660     *got_sub_ptr = 0;
2661     get_subtitle_defaults(sub);
2662
2663     if ((avctx->codec->capabilities & AV_CODEC_CAP_DELAY) || avpkt->size) {
2664         AVPacket pkt_recoded;
2665         AVPacket tmp = *avpkt;
2666         int did_split = av_packet_split_side_data(&tmp);
2667         //apply_param_change(avctx, &tmp);
2668
2669         if (did_split) {
2670             /* FFMIN() prevents overflow in case the packet wasn't allocated with
2671              * proper padding.
2672              * If the side data is smaller than the buffer padding size, the
2673              * remaining bytes should have already been filled with zeros by the
2674              * original packet allocation anyway. */
2675             memset(tmp.data + tmp.size, 0,
2676                    FFMIN(avpkt->size - tmp.size, AV_INPUT_BUFFER_PADDING_SIZE));
2677         }
2678
2679         pkt_recoded = tmp;
2680         ret = recode_subtitle(avctx, &pkt_recoded, &tmp);
2681         if (ret < 0) {
2682             *got_sub_ptr = 0;
2683         } else {
2684             avctx->internal->pkt = &pkt_recoded;
2685
2686             if (avctx->pkt_timebase.num && avpkt->pts != AV_NOPTS_VALUE)
2687                 sub->pts = av_rescale_q(avpkt->pts,
2688                                         avctx->pkt_timebase, AV_TIME_BASE_Q);
2689             ret = avctx->codec->decode(avctx, sub, got_sub_ptr, &pkt_recoded);
2690             av_assert1((ret >= 0) >= !!*got_sub_ptr &&
2691                        !!*got_sub_ptr >= !!sub->num_rects);
2692
2693 #if FF_API_ASS_TIMING
2694             if (avctx->sub_text_format == FF_SUB_TEXT_FMT_ASS_WITH_TIMINGS
2695                 && *got_sub_ptr && sub->num_rects) {
2696                 const AVRational tb = avctx->pkt_timebase.num ? avctx->pkt_timebase
2697                                                               : avctx->time_base;
2698                 int err = convert_sub_to_old_ass_form(sub, avpkt, tb);
2699                 if (err < 0)
2700                     ret = err;
2701             }
2702 #endif
2703
2704             if (sub->num_rects && !sub->end_display_time && avpkt->duration &&
2705                 avctx->pkt_timebase.num) {
2706                 AVRational ms = { 1, 1000 };
2707                 sub->end_display_time = av_rescale_q(avpkt->duration,
2708                                                      avctx->pkt_timebase, ms);
2709             }
2710
2711             for (i = 0; i < sub->num_rects; i++) {
2712                 if (sub->rects[i]->ass && !utf8_check(sub->rects[i]->ass)) {
2713                     av_log(avctx, AV_LOG_ERROR,
2714                            "Invalid UTF-8 in decoded subtitles text; "
2715                            "maybe missing -sub_charenc option\n");
2716                     avsubtitle_free(sub);
2717                     return AVERROR_INVALIDDATA;
2718                 }
2719             }
2720
2721             if (tmp.data != pkt_recoded.data) { // did we recode?
2722                 /* prevent from destroying side data from original packet */
2723                 pkt_recoded.side_data = NULL;
2724                 pkt_recoded.side_data_elems = 0;
2725
2726                 av_packet_unref(&pkt_recoded);
2727             }
2728             if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB)
2729                 sub->format = 0;
2730             else if (avctx->codec_descriptor->props & AV_CODEC_PROP_TEXT_SUB)
2731                 sub->format = 1;
2732             avctx->internal->pkt = NULL;
2733         }
2734
2735         if (did_split) {
2736             av_packet_free_side_data(&tmp);
2737             if(ret == tmp.size)
2738                 ret = avpkt->size;
2739         }
2740
2741         if (*got_sub_ptr)
2742             avctx->frame_number++;
2743     }
2744
2745     return ret;
2746 }
2747
2748 void avsubtitle_free(AVSubtitle *sub)
2749 {
2750     int i;
2751
2752     for (i = 0; i < sub->num_rects; i++) {
2753         av_freep(&sub->rects[i]->data[0]);
2754         av_freep(&sub->rects[i]->data[1]);
2755         av_freep(&sub->rects[i]->data[2]);
2756         av_freep(&sub->rects[i]->data[3]);
2757         av_freep(&sub->rects[i]->text);
2758         av_freep(&sub->rects[i]->ass);
2759         av_freep(&sub->rects[i]);
2760     }
2761
2762     av_freep(&sub->rects);
2763
2764     memset(sub, 0, sizeof(AVSubtitle));
2765 }
2766
2767 static int do_decode(AVCodecContext *avctx, AVPacket *pkt)
2768 {
2769     int got_frame;
2770     int ret;
2771
2772     av_assert0(!avctx->internal->buffer_frame->buf[0]);
2773
2774     if (!pkt)
2775         pkt = avctx->internal->buffer_pkt;
2776
2777     // This is the lesser evil. The field is for compatibility with legacy users
2778     // of the legacy API, and users using the new API should not be forced to
2779     // even know about this field.
2780     avctx->refcounted_frames = 1;
2781
2782     // Some codecs (at least wma lossless) will crash when feeding drain packets
2783     // after EOF was signaled.
2784     if (avctx->internal->draining_done)
2785         return AVERROR_EOF;
2786
2787     if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
2788         ret = avcodec_decode_video2(avctx, avctx->internal->buffer_frame,
2789                                     &got_frame, pkt);
2790         if (ret >= 0)
2791             ret = pkt->size;
2792     } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
2793         ret = avcodec_decode_audio4(avctx, avctx->internal->buffer_frame,
2794                                     &got_frame, pkt);
2795     } else {
2796         ret = AVERROR(EINVAL);
2797     }
2798
2799     if (ret == AVERROR(EAGAIN))
2800         ret = pkt->size;
2801
2802     if (ret < 0)
2803         return ret;
2804
2805     if (avctx->internal->draining && !got_frame)
2806         avctx->internal->draining_done = 1;
2807
2808     if (ret >= pkt->size) {
2809         av_packet_unref(avctx->internal->buffer_pkt);
2810     } else {
2811         int consumed = ret;
2812
2813         if (pkt != avctx->internal->buffer_pkt) {
2814             av_packet_unref(avctx->internal->buffer_pkt);
2815             if ((ret = av_packet_ref(avctx->internal->buffer_pkt, pkt)) < 0)
2816                 return ret;
2817         }
2818
2819         avctx->internal->buffer_pkt->data += consumed;
2820         avctx->internal->buffer_pkt->size -= consumed;
2821         avctx->internal->buffer_pkt->pts   = AV_NOPTS_VALUE;
2822         avctx->internal->buffer_pkt->dts   = AV_NOPTS_VALUE;
2823     }
2824
2825     if (got_frame)
2826         av_assert0(avctx->internal->buffer_frame->buf[0]);
2827
2828     return 0;
2829 }
2830
2831 int attribute_align_arg avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
2832 {
2833     int ret;
2834
2835     if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec))
2836         return AVERROR(EINVAL);
2837
2838     if (avctx->internal->draining)
2839         return AVERROR_EOF;
2840
2841     if (avpkt && !avpkt->size && avpkt->data)
2842         return AVERROR(EINVAL);
2843
2844     if (!avpkt || !avpkt->size) {
2845         avctx->internal->draining = 1;
2846         avpkt = NULL;
2847
2848         if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY))
2849             return 0;
2850     }
2851
2852     if (avctx->codec->send_packet) {
2853         if (avpkt) {
2854             AVPacket tmp = *avpkt;
2855             int did_split = av_packet_split_side_data(&tmp);
2856             ret = apply_param_change(avctx, &tmp);
2857             if (ret >= 0)
2858                 ret = avctx->codec->send_packet(avctx, &tmp);
2859             if (did_split)
2860                 av_packet_free_side_data(&tmp);
2861             return ret;
2862         } else {
2863             return avctx->codec->send_packet(avctx, NULL);
2864         }
2865     }
2866
2867     // Emulation via old API. Assume avpkt is likely not refcounted, while
2868     // decoder output is always refcounted, and avoid copying.
2869
2870     if (avctx->internal->buffer_pkt->size || avctx->internal->buffer_frame->buf[0])
2871         return AVERROR(EAGAIN);
2872
2873     // The goal is decoding the first frame of the packet without using memcpy,
2874     // because the common case is having only 1 frame per packet (especially
2875     // with video, but audio too). In other cases, it can't be avoided, unless
2876     // the user is feeding refcounted packets.
2877     return do_decode(avctx, (AVPacket *)avpkt);
2878 }
2879
2880 int attribute_align_arg avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
2881 {
2882     int ret;
2883
2884     av_frame_unref(frame);
2885
2886     if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec))
2887         return AVERROR(EINVAL);
2888
2889     if (avctx->codec->receive_frame) {
2890         if (avctx->internal->draining && !(avctx->codec->capabilities & AV_CODEC_CAP_DELAY))
2891             return AVERROR_EOF;
2892         ret = avctx->codec->receive_frame(avctx, frame);
2893         if (ret >= 0) {
2894             if (av_frame_get_best_effort_timestamp(frame) == AV_NOPTS_VALUE) {
2895                 av_frame_set_best_effort_timestamp(frame,
2896                     guess_correct_pts(avctx, frame->pts, frame->pkt_dts));
2897             }
2898         }
2899         return ret;
2900     }
2901
2902     // Emulation via old API.
2903
2904     if (!avctx->internal->buffer_frame->buf[0]) {
2905         if (!avctx->internal->buffer_pkt->size && !avctx->internal->draining)
2906             return AVERROR(EAGAIN);
2907
2908         while (1) {
2909             if ((ret = do_decode(avctx, avctx->internal->buffer_pkt)) < 0) {
2910                 av_packet_unref(avctx->internal->buffer_pkt);
2911                 return ret;
2912             }
2913             // Some audio decoders may consume partial data without returning
2914             // a frame (fate-wmapro-2ch). There is no way to make the caller
2915             // call avcodec_receive_frame() again without returning a frame,
2916             // so try to decode more in these cases.
2917             if (avctx->internal->buffer_frame->buf[0] ||
2918                 !avctx->internal->buffer_pkt->size)
2919                 break;
2920         }
2921     }
2922
2923     if (!avctx->internal->buffer_frame->buf[0])
2924         return avctx->internal->draining ? AVERROR_EOF : AVERROR(EAGAIN);
2925
2926     av_frame_move_ref(frame, avctx->internal->buffer_frame);
2927     return 0;
2928 }
2929
2930 static int do_encode(AVCodecContext *avctx, const AVFrame *frame, int *got_packet)
2931 {
2932     int ret;
2933     *got_packet = 0;
2934
2935     av_packet_unref(avctx->internal->buffer_pkt);
2936     avctx->internal->buffer_pkt_valid = 0;
2937
2938     if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
2939         ret = avcodec_encode_video2(avctx, avctx->internal->buffer_pkt,
2940                                     frame, got_packet);
2941     } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
2942         ret = avcodec_encode_audio2(avctx, avctx->internal->buffer_pkt,
2943                                     frame, got_packet);
2944     } else {
2945         ret = AVERROR(EINVAL);
2946     }
2947
2948     if (ret >= 0 && *got_packet) {
2949         // Encoders must always return ref-counted buffers.
2950         // Side-data only packets have no data and can be not ref-counted.
2951         av_assert0(!avctx->internal->buffer_pkt->data || avctx->internal->buffer_pkt->buf);
2952         avctx->internal->buffer_pkt_valid = 1;
2953         ret = 0;
2954     } else {
2955         av_packet_unref(avctx->internal->buffer_pkt);
2956     }
2957
2958     return ret;
2959 }
2960
2961 int attribute_align_arg avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame)
2962 {
2963     if (!avcodec_is_open(avctx) || !av_codec_is_encoder(avctx->codec))
2964         return AVERROR(EINVAL);
2965
2966     if (avctx->internal->draining)
2967         return AVERROR_EOF;
2968
2969     if (!frame) {
2970         avctx->internal->draining = 1;
2971
2972         if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY))
2973             return 0;
2974     }
2975
2976     if (avctx->codec->send_frame)
2977         return avctx->codec->send_frame(avctx, frame);
2978
2979     // Emulation via old API. Do it here instead of avcodec_receive_packet, because:
2980     // 1. if the AVFrame is not refcounted, the copying will be much more
2981     //    expensive than copying the packet data
2982     // 2. assume few users use non-refcounted AVPackets, so usually no copy is
2983     //    needed
2984
2985     if (avctx->internal->buffer_pkt_valid)
2986         return AVERROR(EAGAIN);
2987
2988     return do_encode(avctx, frame, &(int){0});
2989 }
2990
2991 int attribute_align_arg avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)
2992 {
2993     av_packet_unref(avpkt);
2994
2995     if (!avcodec_is_open(avctx) || !av_codec_is_encoder(avctx->codec))
2996         return AVERROR(EINVAL);
2997
2998     if (avctx->codec->receive_packet) {
2999         if (avctx->internal->draining && !(avctx->codec->capabilities & AV_CODEC_CAP_DELAY))
3000             return AVERROR_EOF;
3001         return avctx->codec->receive_packet(avctx, avpkt);
3002     }
3003
3004     // Emulation via old API.
3005
3006     if (!avctx->internal->buffer_pkt_valid) {
3007         int got_packet;
3008         int ret;
3009         if (!avctx->internal->draining)
3010             return AVERROR(EAGAIN);
3011         ret = do_encode(avctx, NULL, &got_packet);
3012         if (ret < 0)
3013             return ret;
3014         if (ret >= 0 && !got_packet)
3015             return AVERROR_EOF;
3016     }
3017
3018     av_packet_move_ref(avpkt, avctx->internal->buffer_pkt);
3019     avctx->internal->buffer_pkt_valid = 0;
3020     return 0;
3021 }
3022
3023 av_cold int avcodec_close(AVCodecContext *avctx)
3024 {
3025     int i;
3026
3027     if (!avctx)
3028         return 0;
3029
3030     if (avcodec_is_open(avctx)) {
3031         FramePool *pool = avctx->internal->pool;
3032         if (CONFIG_FRAME_THREAD_ENCODER &&
3033             avctx->internal->frame_thread_encoder && avctx->thread_count > 1) {
3034             ff_frame_thread_encoder_free(avctx);
3035         }
3036         if (HAVE_THREADS && avctx->internal->thread_ctx)
3037             ff_thread_free(avctx);
3038         if (avctx->codec && avctx->codec->close)
3039             avctx->codec->close(avctx);
3040         avctx->internal->byte_buffer_size = 0;
3041         av_freep(&avctx->internal->byte_buffer);
3042         av_frame_free(&avctx->internal->to_free);
3043         av_frame_free(&avctx->internal->buffer_frame);
3044         av_packet_free(&avctx->internal->buffer_pkt);
3045         for (i = 0; i < FF_ARRAY_ELEMS(pool->pools); i++)
3046             av_buffer_pool_uninit(&pool->pools[i]);
3047         av_freep(&avctx->internal->pool);
3048
3049         if (avctx->hwaccel && avctx->hwaccel->uninit)
3050             avctx->hwaccel->uninit(avctx);
3051         av_freep(&avctx->internal->hwaccel_priv_data);
3052
3053         av_freep(&avctx->internal);
3054     }
3055
3056     for (i = 0; i < avctx->nb_coded_side_data; i++)
3057         av_freep(&avctx->coded_side_data[i].data);
3058     av_freep(&avctx->coded_side_data);
3059     avctx->nb_coded_side_data = 0;
3060
3061     av_buffer_unref(&avctx->hw_frames_ctx);
3062
3063     if (avctx->priv_data && avctx->codec && avctx->codec->priv_class)
3064         av_opt_free(avctx->priv_data);
3065     av_opt_free(avctx);
3066     av_freep(&avctx->priv_data);
3067     if (av_codec_is_encoder(avctx->codec)) {
3068         av_freep(&avctx->extradata);
3069 #if FF_API_CODED_FRAME
3070 FF_DISABLE_DEPRECATION_WARNINGS
3071         av_frame_free(&avctx->coded_frame);
3072 FF_ENABLE_DEPRECATION_WARNINGS
3073 #endif
3074     }
3075     avctx->codec = NULL;
3076     avctx->active_thread_type = 0;
3077
3078     return 0;
3079 }
3080
3081 static enum AVCodecID remap_deprecated_codec_id(enum AVCodecID id)
3082 {
3083     switch(id){
3084         //This is for future deprecatec codec ids, its empty since
3085         //last major bump but will fill up again over time, please don't remove it
3086         default                                         : return id;
3087     }
3088 }
3089
3090 static AVCodec *find_encdec(enum AVCodecID id, int encoder)
3091 {
3092     AVCodec *p, *experimental = NULL;
3093     p = first_avcodec;
3094     id= remap_deprecated_codec_id(id);
3095     while (p) {
3096         if ((encoder ? av_codec_is_encoder(p) : av_codec_is_decoder(p)) &&
3097             p->id == id) {
3098             if (p->capabilities & AV_CODEC_CAP_EXPERIMENTAL && !experimental) {
3099                 experimental = p;
3100             } else
3101                 return p;
3102         }
3103         p = p->next;
3104     }
3105     return experimental;
3106 }
3107
3108 AVCodec *avcodec_find_encoder(enum AVCodecID id)
3109 {
3110     return find_encdec(id, 1);
3111 }
3112
3113 AVCodec *avcodec_find_encoder_by_name(const char *name)
3114 {
3115     AVCodec *p;
3116     if (!name)
3117         return NULL;
3118     p = first_avcodec;
3119     while (p) {
3120         if (av_codec_is_encoder(p) && strcmp(name, p->name) == 0)
3121             return p;
3122         p = p->next;
3123     }
3124     return NULL;
3125 }
3126
3127 AVCodec *avcodec_find_decoder(enum AVCodecID id)
3128 {
3129     return find_encdec(id, 0);
3130 }
3131
3132 AVCodec *avcodec_find_decoder_by_name(const char *name)
3133 {
3134     AVCodec *p;
3135     if (!name)
3136         return NULL;
3137     p = first_avcodec;
3138     while (p) {
3139         if (av_codec_is_decoder(p) && strcmp(name, p->name) == 0)
3140             return p;
3141         p = p->next;
3142     }
3143     return NULL;
3144 }
3145
3146 const char *avcodec_get_name(enum AVCodecID id)
3147 {
3148     const AVCodecDescriptor *cd;
3149     AVCodec *codec;
3150
3151     if (id == AV_CODEC_ID_NONE)
3152         return "none";
3153     cd = avcodec_descriptor_get(id);
3154     if (cd)
3155         return cd->name;
3156     av_log(NULL, AV_LOG_WARNING, "Codec 0x%x is not in the full list.\n", id);
3157     codec = avcodec_find_decoder(id);
3158     if (codec)
3159         return codec->name;
3160     codec = avcodec_find_encoder(id);
3161     if (codec)
3162         return codec->name;
3163     return "unknown_codec";
3164 }
3165
3166 size_t av_get_codec_tag_string(char *buf, size_t buf_size, unsigned int codec_tag)
3167 {
3168     int i, len, ret = 0;
3169
3170 #define TAG_PRINT(x)                                              \
3171     (((x) >= '0' && (x) <= '9') ||                                \
3172      ((x) >= 'a' && (x) <= 'z') || ((x) >= 'A' && (x) <= 'Z') ||  \
3173      ((x) == '.' || (x) == ' ' || (x) == '-' || (x) == '_'))
3174
3175     for (i = 0; i < 4; i++) {
3176         len = snprintf(buf, buf_size,
3177                        TAG_PRINT(codec_tag & 0xFF) ? "%c" : "[%d]", codec_tag & 0xFF);
3178         buf        += len;
3179         buf_size    = buf_size > len ? buf_size - len : 0;
3180         ret        += len;
3181         codec_tag >>= 8;
3182     }
3183     return ret;
3184 }
3185
3186 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
3187 {
3188     const char *codec_type;
3189     const char *codec_name;
3190     const char *profile = NULL;
3191     int64_t bitrate;
3192     int new_line = 0;
3193     AVRational display_aspect_ratio;
3194     const char *separator = enc->dump_separator ? (const char *)enc->dump_separator : ", ";
3195
3196     if (!buf || buf_size <= 0)
3197         return;
3198     codec_type = av_get_media_type_string(enc->codec_type);
3199     codec_name = avcodec_get_name(enc->codec_id);
3200     profile = avcodec_profile_name(enc->codec_id, enc->profile);
3201
3202     snprintf(buf, buf_size, "%s: %s", codec_type ? codec_type : "unknown",
3203              codec_name);
3204     buf[0] ^= 'a' ^ 'A'; /* first letter in uppercase */
3205
3206     if (enc->codec && strcmp(enc->codec->name, codec_name))
3207         snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s)", enc->codec->name);
3208
3209     if (profile)
3210         snprintf(buf + strlen(buf), buf_size - strlen(buf), " (%s)", profile);
3211     if (   enc->codec_type == AVMEDIA_TYPE_VIDEO
3212         && av_log_get_level() >= AV_LOG_VERBOSE
3213         && enc->refs)
3214         snprintf(buf + strlen(buf), buf_size - strlen(buf),
3215                  ", %d reference frame%s",
3216                  enc->refs, enc->refs > 1 ? "s" : "");
3217
3218     if (enc->codec_tag) {
3219         char tag_buf[32];
3220         av_get_codec_tag_string(tag_buf, sizeof(tag_buf), enc->codec_tag);
3221         snprintf(buf + strlen(buf), buf_size - strlen(buf),
3222                  " (%s / 0x%04X)", tag_buf, enc->codec_tag);
3223     }
3224
3225     switch (enc->codec_type) {
3226     case AVMEDIA_TYPE_VIDEO:
3227         {
3228             char detail[256] = "(";
3229
3230             av_strlcat(buf, separator, buf_size);
3231
3232             snprintf(buf + strlen(buf), buf_size - strlen(buf),
3233                  "%s", enc->pix_fmt == AV_PIX_FMT_NONE ? "none" :
3234                      av_get_pix_fmt_name(enc->pix_fmt));
3235             if (enc->bits_per_raw_sample && enc->pix_fmt != AV_PIX_FMT_NONE &&
3236                 enc->bits_per_raw_sample < av_pix_fmt_desc_get(enc->pix_fmt)->comp[0].depth)
3237                 av_strlcatf(detail, sizeof(detail), "%d bpc, ", enc->bits_per_raw_sample);
3238             if (enc->color_range != AVCOL_RANGE_UNSPECIFIED)
3239                 av_strlcatf(detail, sizeof(detail), "%s, ",
3240                             av_color_range_name(enc->color_range));
3241
3242             if (enc->colorspace != AVCOL_SPC_UNSPECIFIED ||
3243                 enc->color_primaries != AVCOL_PRI_UNSPECIFIED ||
3244                 enc->color_trc != AVCOL_TRC_UNSPECIFIED) {
3245                 if (enc->colorspace != (int)enc->color_primaries ||
3246                     enc->colorspace != (int)enc->color_trc) {
3247                     new_line = 1;
3248                     av_strlcatf(detail, sizeof(detail), "%s/%s/%s, ",
3249                                 av_color_space_name(enc->colorspace),
3250                                 av_color_primaries_name(enc->color_primaries),
3251                                 av_color_transfer_name(enc->color_trc));
3252                 } else
3253                     av_strlcatf(detail, sizeof(detail), "%s, ",
3254                                 av_get_colorspace_name(enc->colorspace));
3255             }
3256
3257             if (enc->field_order != AV_FIELD_UNKNOWN) {
3258                 const char *field_order = "progressive";
3259                 if (enc->field_order == AV_FIELD_TT)
3260                     field_order = "top first";
3261                 else if (enc->field_order == AV_FIELD_BB)
3262                     field_order = "bottom first";
3263                 else if (enc->field_order == AV_FIELD_TB)
3264                     field_order = "top coded first (swapped)";
3265                 else if (enc->field_order == AV_FIELD_BT)
3266                     field_order = "bottom coded first (swapped)";
3267
3268                 av_strlcatf(detail, sizeof(detail), "%s, ", field_order);
3269             }
3270
3271             if (av_log_get_level() >= AV_LOG_VERBOSE &&
3272                 enc->chroma_sample_location != AVCHROMA_LOC_UNSPECIFIED)
3273                 av_strlcatf(detail, sizeof(detail), "%s, ",
3274                             av_chroma_location_name(enc->chroma_sample_location));
3275
3276             if (strlen(detail) > 1) {
3277                 detail[strlen(detail) - 2] = 0;
3278                 av_strlcatf(buf, buf_size, "%s)", detail);
3279             }
3280         }
3281
3282         if (enc->width) {
3283             av_strlcat(buf, new_line ? separator : ", ", buf_size);
3284
3285             snprintf(buf + strlen(buf), buf_size - strlen(buf),
3286                      "%dx%d",
3287                      enc->width, enc->height);
3288
3289             if (av_log_get_level() >= AV_LOG_VERBOSE &&
3290                 (enc->width != enc->coded_width ||
3291                  enc->height != enc->coded_height))
3292                 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3293                          " (%dx%d)", enc->coded_width, enc->coded_height);
3294
3295             if (enc->sample_aspect_ratio.num) {
3296                 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3297                           enc->width * (int64_t)enc->sample_aspect_ratio.num,
3298                           enc->height * (int64_t)enc->sample_aspect_ratio.den,
3299                           1024 * 1024);
3300                 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3301                          " [SAR %d:%d DAR %d:%d]",
3302                          enc->sample_aspect_ratio.num, enc->sample_aspect_ratio.den,
3303                          display_aspect_ratio.num, display_aspect_ratio.den);
3304             }
3305             if (av_log_get_level() >= AV_LOG_DEBUG) {
3306                 int g = av_gcd(enc->time_base.num, enc->time_base.den);
3307                 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3308                          ", %d/%d",
3309                          enc->time_base.num / g, enc->time_base.den / g);
3310             }
3311         }
3312         if (encode) {
3313             snprintf(buf + strlen(buf), buf_size - strlen(buf),
3314                      ", q=%d-%d", enc->qmin, enc->qmax);
3315         } else {
3316             if (enc->properties & FF_CODEC_PROPERTY_CLOSED_CAPTIONS)
3317                 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3318                          ", Closed Captions");
3319             if (enc->properties & FF_CODEC_PROPERTY_LOSSLESS)
3320                 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3321                          ", lossless");
3322         }
3323         break;
3324     case AVMEDIA_TYPE_AUDIO:
3325         av_strlcat(buf, separator, buf_size);
3326
3327         if (enc->sample_rate) {
3328             snprintf(buf + strlen(buf), buf_size - strlen(buf),
3329                      "%d Hz, ", enc->sample_rate);
3330         }
3331         av_get_channel_layout_string(buf + strlen(buf), buf_size - strlen(buf), enc->channels, enc->channel_layout);
3332         if (enc->sample_fmt != AV_SAMPLE_FMT_NONE) {
3333             snprintf(buf + strlen(buf), buf_size - strlen(buf),
3334                      ", %s", av_get_sample_fmt_name(enc->sample_fmt));
3335         }
3336         if (   enc->bits_per_raw_sample > 0
3337             && enc->bits_per_raw_sample != av_get_bytes_per_sample(enc->sample_fmt) * 8)
3338             snprintf(buf + strlen(buf), buf_size - strlen(buf),
3339                      " (%d bit)", enc->bits_per_raw_sample);
3340         if (av_log_get_level() >= AV_LOG_VERBOSE) {
3341             if (enc->initial_padding)
3342                 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3343                          ", delay %d", enc->initial_padding);
3344             if (enc->trailing_padding)
3345                 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3346                          ", padding %d", enc->trailing_padding);
3347         }
3348         break;
3349     case AVMEDIA_TYPE_DATA:
3350         if (av_log_get_level() >= AV_LOG_DEBUG) {
3351             int g = av_gcd(enc->time_base.num, enc->time_base.den);
3352             if (g)
3353                 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3354                          ", %d/%d",
3355                          enc->time_base.num / g, enc->time_base.den / g);
3356         }
3357         break;
3358     case AVMEDIA_TYPE_SUBTITLE:
3359         if (enc->width)
3360             snprintf(buf + strlen(buf), buf_size - strlen(buf),
3361                      ", %dx%d", enc->width, enc->height);
3362         break;
3363     default:
3364         return;
3365     }
3366     if (encode) {
3367         if (enc->flags & AV_CODEC_FLAG_PASS1)
3368             snprintf(buf + strlen(buf), buf_size - strlen(buf),
3369                      ", pass 1");
3370         if (enc->flags & AV_CODEC_FLAG_PASS2)
3371             snprintf(buf + strlen(buf), buf_size - strlen(buf),
3372                      ", pass 2");
3373     }
3374     bitrate = get_bit_rate(enc);
3375     if (bitrate != 0) {
3376         snprintf(buf + strlen(buf), buf_size - strlen(buf),
3377                  ", %"PRId64" kb/s", bitrate / 1000);
3378     } else if (enc->rc_max_rate > 0) {
3379         snprintf(buf + strlen(buf), buf_size - strlen(buf),
3380                  ", max. %"PRId64" kb/s", (int64_t)enc->rc_max_rate / 1000);
3381     }
3382 }
3383
3384 const char *av_get_profile_name(const AVCodec *codec, int profile)
3385 {
3386     const AVProfile *p;
3387     if (profile == FF_PROFILE_UNKNOWN || !codec->profiles)
3388         return NULL;
3389
3390     for (p = codec->profiles; p->profile != FF_PROFILE_UNKNOWN; p++)
3391         if (p->profile == profile)
3392             return p->name;
3393
3394     return NULL;
3395 }
3396
3397 const char *avcodec_profile_name(enum AVCodecID codec_id, int profile)
3398 {
3399     const AVCodecDescriptor *desc = avcodec_descriptor_get(codec_id);
3400     const AVProfile *p;
3401
3402     if (profile == FF_PROFILE_UNKNOWN || !desc || !desc->profiles)
3403         return NULL;
3404
3405     for (p = desc->profiles; p->profile != FF_PROFILE_UNKNOWN; p++)
3406         if (p->profile == profile)
3407             return p->name;
3408
3409     return NULL;
3410 }
3411
3412 unsigned avcodec_version(void)
3413 {
3414 //    av_assert0(AV_CODEC_ID_V410==164);
3415     av_assert0(AV_CODEC_ID_PCM_S8_PLANAR==65563);
3416     av_assert0(AV_CODEC_ID_ADPCM_G722==69660);
3417 //     av_assert0(AV_CODEC_ID_BMV_AUDIO==86071);
3418     av_assert0(AV_CODEC_ID_SRT==94216);
3419     av_assert0(LIBAVCODEC_VERSION_MICRO >= 100);
3420
3421     return LIBAVCODEC_VERSION_INT;
3422 }
3423
3424 const char *avcodec_configuration(void)
3425 {
3426     return FFMPEG_CONFIGURATION;
3427 }
3428
3429 const char *avcodec_license(void)
3430 {
3431 #define LICENSE_PREFIX "libavcodec license: "
3432     return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
3433 }
3434
3435 void avcodec_flush_buffers(AVCodecContext *avctx)
3436 {
3437     avctx->internal->draining      = 0;
3438     avctx->internal->draining_done = 0;
3439     av_frame_unref(avctx->internal->buffer_frame);
3440     av_packet_unref(avctx->internal->buffer_pkt);
3441     avctx->internal->buffer_pkt_valid = 0;
3442
3443     if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME)
3444         ff_thread_flush(avctx);
3445     else if (avctx->codec->flush)
3446         avctx->codec->flush(avctx);
3447
3448     avctx->pts_correction_last_pts =
3449     avctx->pts_correction_last_dts = INT64_MIN;
3450
3451     if (!avctx->refcounted_frames)
3452         av_frame_unref(avctx->internal->to_free);
3453 }
3454
3455 int av_get_exact_bits_per_sample(enum AVCodecID codec_id)
3456 {
3457     switch (codec_id) {
3458     case AV_CODEC_ID_8SVX_EXP:
3459     case AV_CODEC_ID_8SVX_FIB:
3460     case AV_CODEC_ID_ADPCM_CT:
3461     case AV_CODEC_ID_ADPCM_IMA_APC:
3462     case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
3463     case AV_CODEC_ID_ADPCM_IMA_OKI:
3464     case AV_CODEC_ID_ADPCM_IMA_WS:
3465     case AV_CODEC_ID_ADPCM_G722:
3466     case AV_CODEC_ID_ADPCM_YAMAHA:
3467     case AV_CODEC_ID_ADPCM_AICA:
3468         return 4;
3469     case AV_CODEC_ID_DSD_LSBF:
3470     case AV_CODEC_ID_DSD_MSBF:
3471     case AV_CODEC_ID_DSD_LSBF_PLANAR:
3472     case AV_CODEC_ID_DSD_MSBF_PLANAR:
3473     case AV_CODEC_ID_PCM_ALAW:
3474     case AV_CODEC_ID_PCM_MULAW:
3475     case AV_CODEC_ID_PCM_S8:
3476     case AV_CODEC_ID_PCM_S8_PLANAR:
3477     case AV_CODEC_ID_PCM_U8:
3478     case AV_CODEC_ID_PCM_ZORK:
3479     case AV_CODEC_ID_SDX2_DPCM:
3480         return 8;
3481     case AV_CODEC_ID_PCM_S16BE:
3482     case AV_CODEC_ID_PCM_S16BE_PLANAR:
3483     case AV_CODEC_ID_PCM_S16LE:
3484     case AV_CODEC_ID_PCM_S16LE_PLANAR:
3485     case AV_CODEC_ID_PCM_U16BE:
3486     case AV_CODEC_ID_PCM_U16LE:
3487         return 16;
3488     case AV_CODEC_ID_PCM_S24DAUD:
3489     case AV_CODEC_ID_PCM_S24BE:
3490     case AV_CODEC_ID_PCM_S24LE:
3491     case AV_CODEC_ID_PCM_S24LE_PLANAR:
3492     case AV_CODEC_ID_PCM_U24BE:
3493     case AV_CODEC_ID_PCM_U24LE:
3494         return 24;
3495     case AV_CODEC_ID_PCM_S32BE:
3496     case AV_CODEC_ID_PCM_S32LE:
3497     case AV_CODEC_ID_PCM_S32LE_PLANAR:
3498     case AV_CODEC_ID_PCM_U32BE:
3499     case AV_CODEC_ID_PCM_U32LE:
3500     case AV_CODEC_ID_PCM_F32BE:
3501     case AV_CODEC_ID_PCM_F32LE:
3502         return 32;
3503     case AV_CODEC_ID_PCM_F64BE:
3504     case AV_CODEC_ID_PCM_F64LE:
3505     case AV_CODEC_ID_PCM_S64BE:
3506     case AV_CODEC_ID_PCM_S64LE:
3507         return 64;
3508     default:
3509         return 0;
3510     }
3511 }
3512
3513 enum AVCodecID av_get_pcm_codec(enum AVSampleFormat fmt, int be)
3514 {
3515     static const enum AVCodecID map[AV_SAMPLE_FMT_NB][2] = {
3516         [AV_SAMPLE_FMT_U8  ] = { AV_CODEC_ID_PCM_U8,    AV_CODEC_ID_PCM_U8    },
3517         [AV_SAMPLE_FMT_S16 ] = { AV_CODEC_ID_PCM_S16LE, AV_CODEC_ID_PCM_S16BE },
3518         [AV_SAMPLE_FMT_S32 ] = { AV_CODEC_ID_PCM_S32LE, AV_CODEC_ID_PCM_S32BE },
3519         [AV_SAMPLE_FMT_FLT ] = { AV_CODEC_ID_PCM_F32LE, AV_CODEC_ID_PCM_F32BE },
3520         [AV_SAMPLE_FMT_DBL ] = { AV_CODEC_ID_PCM_F64LE, AV_CODEC_ID_PCM_F64BE },
3521         [AV_SAMPLE_FMT_U8P ] = { AV_CODEC_ID_PCM_U8,    AV_CODEC_ID_PCM_U8    },
3522         [AV_SAMPLE_FMT_S16P] = { AV_CODEC_ID_PCM_S16LE, AV_CODEC_ID_PCM_S16BE },
3523         [AV_SAMPLE_FMT_S32P] = { AV_CODEC_ID_PCM_S32LE, AV_CODEC_ID_PCM_S32BE },
3524         [AV_SAMPLE_FMT_S64P] = { AV_CODEC_ID_PCM_S64LE, AV_CODEC_ID_PCM_S64BE },
3525         [AV_SAMPLE_FMT_FLTP] = { AV_CODEC_ID_PCM_F32LE, AV_CODEC_ID_PCM_F32BE },
3526         [AV_SAMPLE_FMT_DBLP] = { AV_CODEC_ID_PCM_F64LE, AV_CODEC_ID_PCM_F64BE },
3527     };
3528     if (fmt < 0 || fmt >= AV_SAMPLE_FMT_NB)
3529         return AV_CODEC_ID_NONE;
3530     if (be < 0 || be > 1)
3531         be = AV_NE(1, 0);
3532     return map[fmt][be];
3533 }
3534
3535 int av_get_bits_per_sample(enum AVCodecID codec_id)
3536 {
3537     switch (codec_id) {
3538     case AV_CODEC_ID_ADPCM_SBPRO_2:
3539         return 2;
3540     case AV_CODEC_ID_ADPCM_SBPRO_3:
3541         return 3;
3542     case AV_CODEC_ID_ADPCM_SBPRO_4:
3543     case AV_CODEC_ID_ADPCM_IMA_WAV:
3544     case AV_CODEC_ID_ADPCM_IMA_QT:
3545     case AV_CODEC_ID_ADPCM_SWF:
3546     case AV_CODEC_ID_ADPCM_MS:
3547         return 4;
3548     default:
3549         return av_get_exact_bits_per_sample(codec_id);
3550     }
3551 }
3552
3553 static int get_audio_frame_duration(enum AVCodecID id, int sr, int ch, int ba,
3554                                     uint32_t tag, int bits_per_coded_sample, int64_t bitrate,
3555                                     uint8_t * extradata, int frame_size, int frame_bytes)
3556 {
3557     int bps = av_get_exact_bits_per_sample(id);
3558     int framecount = (ba > 0 && frame_bytes / ba > 0) ? frame_bytes / ba : 1;
3559
3560     /* codecs with an exact constant bits per sample */
3561     if (bps > 0 && ch > 0 && frame_bytes > 0 && ch < 32768 && bps < 32768)
3562         return (frame_bytes * 8LL) / (bps * ch);
3563     bps = bits_per_coded_sample;
3564
3565     /* codecs with a fixed packet duration */
3566     switch (id) {
3567     case AV_CODEC_ID_ADPCM_ADX:    return   32;
3568     case AV_CODEC_ID_ADPCM_IMA_QT: return   64;
3569     case AV_CODEC_ID_ADPCM_EA_XAS: return  128;
3570     case AV_CODEC_ID_AMR_NB:
3571     case AV_CODEC_ID_EVRC:
3572     case AV_CODEC_ID_GSM:
3573     case AV_CODEC_ID_QCELP:
3574     case AV_CODEC_ID_RA_288:       return  160;
3575     case AV_CODEC_ID_AMR_WB:
3576     case AV_CODEC_ID_GSM_MS:       return  320;
3577     case AV_CODEC_ID_MP1:          return  384;
3578     case AV_CODEC_ID_ATRAC1:       return  512;
3579     case AV_CODEC_ID_ATRAC3:       return 1024 * framecount;
3580     case AV_CODEC_ID_ATRAC3P:      return 2048;
3581     case AV_CODEC_ID_MP2:
3582     case AV_CODEC_ID_MUSEPACK7:    return 1152;
3583     case AV_CODEC_ID_AC3:          return 1536;
3584     }
3585
3586     if (sr > 0) {
3587         /* calc from sample rate */
3588         if (id == AV_CODEC_ID_TTA)
3589             return 256 * sr / 245;
3590         else if (id == AV_CODEC_ID_DST)
3591             return 588 * sr / 44100;
3592
3593         if (ch > 0) {
3594             /* calc from sample rate and channels */
3595             if (id == AV_CODEC_ID_BINKAUDIO_DCT)
3596                 return (480 << (sr / 22050)) / ch;
3597         }
3598     }
3599
3600     if (ba > 0) {
3601         /* calc from block_align */
3602         if (id == AV_CODEC_ID_SIPR) {
3603             switch (ba) {
3604             case 20: return 160;
3605             case 19: return 144;
3606             case 29: return 288;
3607             case 37: return 480;
3608             }
3609         } else if (id == AV_CODEC_ID_ILBC) {
3610             switch (ba) {
3611             case 38: return 160;
3612             case 50: return 240;
3613             }
3614         }
3615     }
3616
3617     if (frame_bytes > 0) {
3618         /* calc from frame_bytes only */
3619         if (id == AV_CODEC_ID_TRUESPEECH)
3620             return 240 * (frame_bytes / 32);
3621         if (id == AV_CODEC_ID_NELLYMOSER)
3622             return 256 * (frame_bytes / 64);
3623         if (id == AV_CODEC_ID_RA_144)
3624             return 160 * (frame_bytes / 20);
3625         if (id == AV_CODEC_ID_G723_1)
3626             return 240 * (frame_bytes / 24);
3627
3628         if (bps > 0) {
3629             /* calc from frame_bytes and bits_per_coded_sample */
3630             if (id == AV_CODEC_ID_ADPCM_G726)
3631                 return frame_bytes * 8 / bps;
3632         }
3633
3634         if (ch > 0 && ch < INT_MAX/16) {
3635             /* calc from frame_bytes and channels */
3636             switch (id) {
3637             case AV_CODEC_ID_ADPCM_AFC:
3638                 return frame_bytes / (9 * ch) * 16;
3639             case AV_CODEC_ID_ADPCM_PSX:
3640             case AV_CODEC_ID_ADPCM_DTK:
3641                 return frame_bytes / (16 * ch) * 28;
3642             case AV_CODEC_ID_ADPCM_4XM:
3643             case AV_CODEC_ID_ADPCM_IMA_DAT4:
3644             case AV_CODEC_ID_ADPCM_IMA_ISS:
3645                 return (frame_bytes - 4 * ch) * 2 / ch;
3646             case AV_CODEC_ID_ADPCM_IMA_SMJPEG:
3647                 return (frame_bytes - 4) * 2 / ch;
3648             case AV_CODEC_ID_ADPCM_IMA_AMV:
3649                 return (frame_bytes - 8) * 2 / ch;
3650             case AV_CODEC_ID_ADPCM_THP:
3651             case AV_CODEC_ID_ADPCM_THP_LE:
3652                 if (extradata)
3653                     return frame_bytes * 14 / (8 * ch);
3654                 break;
3655             case AV_CODEC_ID_ADPCM_XA:
3656                 return (frame_bytes / 128) * 224 / ch;
3657             case AV_CODEC_ID_INTERPLAY_DPCM:
3658                 return (frame_bytes - 6 - ch) / ch;
3659             case AV_CODEC_ID_ROQ_DPCM:
3660                 return (frame_bytes - 8) / ch;
3661             case AV_CODEC_ID_XAN_DPCM:
3662                 return (frame_bytes - 2 * ch) / ch;
3663             case AV_CODEC_ID_MACE3:
3664                 return 3 * frame_bytes / ch;
3665             case AV_CODEC_ID_MACE6:
3666                 return 6 * frame_bytes / ch;
3667             case AV_CODEC_ID_PCM_LXF:
3668                 return 2 * (frame_bytes / (5 * ch));
3669             case AV_CODEC_ID_IAC:
3670             case AV_CODEC_ID_IMC:
3671                 return 4 * frame_bytes / ch;
3672             }
3673
3674             if (tag) {
3675                 /* calc from frame_bytes, channels, and codec_tag */
3676                 if (id == AV_CODEC_ID_SOL_DPCM) {
3677                     if (tag == 3)
3678                         return frame_bytes / ch;
3679                     else
3680                         return frame_bytes * 2 / ch;
3681                 }
3682             }
3683
3684             if (ba > 0) {
3685                 /* calc from frame_bytes, channels, and block_align */
3686                 int blocks = frame_bytes / ba;
3687                 switch (id) {
3688                 case AV_CODEC_ID_ADPCM_IMA_WAV:
3689                     if (bps < 2 || bps > 5)
3690                         return 0;
3691                     return blocks * (1 + (ba - 4 * ch) / (bps * ch) * 8);
3692                 case AV_CODEC_ID_ADPCM_IMA_DK3:
3693                     return blocks * (((ba - 16) * 2 / 3 * 4) / ch);
3694                 case AV_CODEC_ID_ADPCM_IMA_DK4:
3695                     return blocks * (1 + (ba - 4 * ch) * 2 / ch);
3696                 case AV_CODEC_ID_ADPCM_IMA_RAD:
3697                     return blocks * ((ba - 4 * ch) * 2 / ch);
3698                 case AV_CODEC_ID_ADPCM_MS:
3699                     return blocks * (2 + (ba - 7 * ch) * 2 / ch);
3700                 case AV_CODEC_ID_ADPCM_MTAF:
3701                     return blocks * (ba - 16) * 2 / ch;
3702                 }
3703             }
3704
3705             if (bps > 0) {
3706                 /* calc from frame_bytes, channels, and bits_per_coded_sample */
3707                 switch (id) {
3708                 case AV_CODEC_ID_PCM_DVD:
3709                     if(bps<4)
3710                         return 0;
3711                     return 2 * (frame_bytes / ((bps * 2 / 8) * ch));
3712                 case AV_CODEC_ID_PCM_BLURAY:
3713                     if(bps<4)
3714                         return 0;
3715                     return frame_bytes / ((FFALIGN(ch, 2) * bps) / 8);
3716                 case AV_CODEC_ID_S302M:
3717                     return 2 * (frame_bytes / ((bps + 4) / 4)) / ch;
3718                 }
3719             }
3720         }
3721     }
3722
3723     /* Fall back on using frame_size */
3724     if (frame_size > 1 && frame_bytes)
3725         return frame_size;
3726
3727     //For WMA we currently have no other means to calculate duration thus we
3728     //do it here by assuming CBR, which is true for all known cases.
3729     if (bitrate > 0 && frame_bytes > 0 && sr > 0 && ba > 1) {
3730         if (id == AV_CODEC_ID_WMAV1 || id == AV_CODEC_ID_WMAV2)
3731             return  (frame_bytes * 8LL * sr) / bitrate;
3732     }
3733
3734     return 0;
3735 }
3736
3737 int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
3738 {
3739     return get_audio_frame_duration(avctx->codec_id, avctx->sample_rate,
3740                                     avctx->channels, avctx->block_align,
3741                                     avctx->codec_tag, avctx->bits_per_coded_sample,
3742                                     avctx->bit_rate, avctx->extradata, avctx->frame_size,
3743                                     frame_bytes);
3744 }
3745
3746 int av_get_audio_frame_duration2(AVCodecParameters *par, int frame_bytes)
3747 {
3748     return get_audio_frame_duration(par->codec_id, par->sample_rate,
3749                                     par->channels, par->block_align,
3750                                     par->codec_tag, par->bits_per_coded_sample,
3751                                     par->bit_rate, par->extradata, par->frame_size,
3752                                     frame_bytes);
3753 }
3754
3755 #if !HAVE_THREADS
3756 int ff_thread_init(AVCodecContext *s)
3757 {
3758     return -1;
3759 }
3760
3761 #endif
3762
3763 unsigned int av_xiphlacing(unsigned char *s, unsigned int v)
3764 {
3765     unsigned int n = 0;
3766
3767     while (v >= 0xff) {
3768         *s++ = 0xff;
3769         v -= 0xff;
3770         n++;
3771     }
3772     *s = v;
3773     n++;
3774     return n;
3775 }
3776
3777 int ff_match_2uint16(const uint16_t(*tab)[2], int size, int a, int b)
3778 {
3779     int i;
3780     for (i = 0; i < size && !(tab[i][0] == a && tab[i][1] == b); i++) ;
3781     return i;
3782 }
3783
3784 #if FF_API_MISSING_SAMPLE
3785 FF_DISABLE_DEPRECATION_WARNINGS
3786 void av_log_missing_feature(void *avc, const char *feature, int want_sample)
3787 {
3788     av_log(avc, AV_LOG_WARNING, "%s is not implemented. Update your FFmpeg "
3789             "version to the newest one from Git. If the problem still "
3790             "occurs, it means that your file has a feature which has not "
3791             "been implemented.\n", feature);
3792     if(want_sample)
3793         av_log_ask_for_sample(avc, NULL);
3794 }
3795
3796 void av_log_ask_for_sample(void *avc, const char *msg, ...)
3797 {
3798     va_list argument_list;
3799
3800     va_start(argument_list, msg);
3801
3802     if (msg)
3803         av_vlog(avc, AV_LOG_WARNING, msg, argument_list);
3804     av_log(avc, AV_LOG_WARNING, "If you want to help, upload a sample "
3805             "of this file to ftp://upload.ffmpeg.org/incoming/ "
3806             "and contact the ffmpeg-devel mailing list. (ffmpeg-devel@ffmpeg.org)\n");
3807
3808     va_end(argument_list);
3809 }
3810 FF_ENABLE_DEPRECATION_WARNINGS
3811 #endif /* FF_API_MISSING_SAMPLE */
3812
3813 static AVHWAccel *first_hwaccel = NULL;
3814 static AVHWAccel **last_hwaccel = &first_hwaccel;
3815
3816 void av_register_hwaccel(AVHWAccel *hwaccel)
3817 {
3818     AVHWAccel **p = last_hwaccel;
3819     hwaccel->next = NULL;
3820     while(*p || avpriv_atomic_ptr_cas((void * volatile *)p, NULL, hwaccel))
3821         p = &(*p)->next;
3822     last_hwaccel = &hwaccel->next;
3823 }
3824
3825 AVHWAccel *av_hwaccel_next(const AVHWAccel *hwaccel)
3826 {
3827     return hwaccel ? hwaccel->next : first_hwaccel;
3828 }
3829
3830 int av_lockmgr_register(int (*cb)(void **mutex, enum AVLockOp op))
3831 {
3832     if (lockmgr_cb) {
3833         // There is no good way to rollback a failure to destroy the
3834         // mutex, so we ignore failures.
3835         lockmgr_cb(&codec_mutex,    AV_LOCK_DESTROY);
3836         lockmgr_cb(&avformat_mutex, AV_LOCK_DESTROY);
3837         lockmgr_cb     = NULL;
3838         codec_mutex    = NULL;
3839         avformat_mutex = NULL;
3840     }
3841
3842     if (cb) {
3843         void *new_codec_mutex    = NULL;
3844         void *new_avformat_mutex = NULL;
3845         int err;
3846         if (err = cb(&new_codec_mutex, AV_LOCK_CREATE)) {
3847             return err > 0 ? AVERROR_UNKNOWN : err;
3848         }
3849         if (err = cb(&new_avformat_mutex, AV_LOCK_CREATE)) {
3850             // Ignore failures to destroy the newly created mutex.
3851             cb(&new_codec_mutex, AV_LOCK_DESTROY);
3852             return err > 0 ? AVERROR_UNKNOWN : err;
3853         }
3854         lockmgr_cb     = cb;
3855         codec_mutex    = new_codec_mutex;
3856         avformat_mutex = new_avformat_mutex;
3857     }
3858
3859     return 0;
3860 }
3861
3862 int ff_lock_avcodec(AVCodecContext *log_ctx, const AVCodec *codec)
3863 {
3864     if (codec->caps_internal & FF_CODEC_CAP_INIT_THREADSAFE || !codec->init)
3865         return 0;
3866
3867     if (lockmgr_cb) {
3868         if ((*lockmgr_cb)(&codec_mutex, AV_LOCK_OBTAIN))
3869             return -1;
3870     }
3871
3872     if (avpriv_atomic_int_add_and_fetch(&entangled_thread_counter, 1) != 1) {
3873         av_log(log_ctx, AV_LOG_ERROR,
3874                "Insufficient thread locking. At least %d threads are "
3875                "calling avcodec_open2() at the same time right now.\n",
3876                entangled_thread_counter);
3877         if (!lockmgr_cb)
3878             av_log(log_ctx, AV_LOG_ERROR, "No lock manager is set, please see av_lockmgr_register()\n");
3879         ff_avcodec_locked = 1;
3880         ff_unlock_avcodec(codec);
3881         return AVERROR(EINVAL);
3882     }
3883     av_assert0(!ff_avcodec_locked);
3884     ff_avcodec_locked = 1;
3885     return 0;
3886 }
3887
3888 int ff_unlock_avcodec(const AVCodec *codec)
3889 {
3890     if (codec->caps_internal & FF_CODEC_CAP_INIT_THREADSAFE || !codec->init)
3891         return 0;
3892
3893     av_assert0(ff_avcodec_locked);
3894     ff_avcodec_locked = 0;
3895     avpriv_atomic_int_add_and_fetch(&entangled_thread_counter, -1);
3896     if (lockmgr_cb) {
3897         if ((*lockmgr_cb)(&codec_mutex, AV_LOCK_RELEASE))
3898             return -1;
3899     }
3900
3901     return 0;
3902 }
3903
3904 int avpriv_lock_avformat(void)
3905 {
3906     if (lockmgr_cb) {
3907         if ((*lockmgr_cb)(&avformat_mutex, AV_LOCK_OBTAIN))
3908             return -1;
3909     }
3910     return 0;
3911 }
3912
3913 int avpriv_unlock_avformat(void)
3914 {
3915     if (lockmgr_cb) {
3916         if ((*lockmgr_cb)(&avformat_mutex, AV_LOCK_RELEASE))
3917             return -1;
3918     }
3919     return 0;
3920 }
3921
3922 unsigned int avpriv_toupper4(unsigned int x)
3923 {
3924     return av_toupper(x & 0xFF) +
3925           (av_toupper((x >>  8) & 0xFF) << 8)  +
3926           (av_toupper((x >> 16) & 0xFF) << 16) +
3927 ((unsigned)av_toupper((x >> 24) & 0xFF) << 24);
3928 }
3929
3930 int ff_thread_ref_frame(ThreadFrame *dst, ThreadFrame *src)
3931 {
3932     int ret;
3933
3934     dst->owner = src->owner;
3935
3936     ret = av_frame_ref(dst->f, src->f);
3937     if (ret < 0)
3938         return ret;
3939
3940     av_assert0(!dst->progress);
3941
3942     if (src->progress &&
3943         !(dst->progress = av_buffer_ref(src->progress))) {
3944         ff_thread_release_buffer(dst->owner, dst);
3945         return AVERROR(ENOMEM);
3946     }
3947
3948     return 0;
3949 }
3950
3951 #if !HAVE_THREADS
3952
3953 enum AVPixelFormat ff_thread_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
3954 {
3955     return ff_get_format(avctx, fmt);
3956 }
3957
3958 int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
3959 {
3960     f->owner = avctx;
3961     return ff_get_buffer(avctx, f->f, flags);
3962 }
3963
3964 void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
3965 {
3966     if (f->f)
3967         av_frame_unref(f->f);
3968 }
3969
3970 void ff_thread_finish_setup(AVCodecContext *avctx)
3971 {
3972 }
3973
3974 void ff_thread_report_progress(ThreadFrame *f, int progress, int field)
3975 {
3976 }
3977
3978 void ff_thread_await_progress(ThreadFrame *f, int progress, int field)
3979 {
3980 }
3981
3982 int ff_thread_can_start_frame(AVCodecContext *avctx)
3983 {
3984     return 1;
3985 }
3986
3987 int ff_alloc_entries(AVCodecContext *avctx, int count)
3988 {
3989     return 0;
3990 }
3991
3992 void ff_reset_entries(AVCodecContext *avctx)
3993 {
3994 }
3995
3996 void ff_thread_await_progress2(AVCodecContext *avctx, int field, int thread, int shift)
3997 {
3998 }
3999
4000 void ff_thread_report_progress2(AVCodecContext *avctx, int field, int thread, int n)
4001 {
4002 }
4003
4004 #endif
4005
4006 int avcodec_is_open(AVCodecContext *s)
4007 {
4008     return !!s->internal;
4009 }
4010
4011 int avpriv_bprint_to_extradata(AVCodecContext *avctx, struct AVBPrint *buf)
4012 {
4013     int ret;
4014     char *str;
4015
4016     ret = av_bprint_finalize(buf, &str);
4017     if (ret < 0)
4018         return ret;
4019     if (!av_bprint_is_complete(buf)) {
4020         av_free(str);
4021         return AVERROR(ENOMEM);
4022     }
4023
4024     avctx->extradata = str;
4025     /* Note: the string is NUL terminated (so extradata can be read as a
4026      * string), but the ending character is not accounted in the size (in
4027      * binary formats you are likely not supposed to mux that character). When
4028      * extradata is copied, it is also padded with AV_INPUT_BUFFER_PADDING_SIZE
4029      * zeros. */
4030     avctx->extradata_size = buf->len;
4031     return 0;
4032 }
4033
4034 const uint8_t *avpriv_find_start_code(const uint8_t *av_restrict p,
4035                                       const uint8_t *end,
4036                                       uint32_t *av_restrict state)
4037 {
4038     int i;
4039
4040     av_assert0(p <= end);
4041     if (p >= end)
4042         return end;
4043
4044     for (i = 0; i < 3; i++) {
4045         uint32_t tmp = *state << 8;
4046         *state = tmp + *(p++);
4047         if (tmp == 0x100 || p == end)
4048             return p;
4049     }
4050
4051     while (p < end) {
4052         if      (p[-1] > 1      ) p += 3;
4053         else if (p[-2]          ) p += 2;
4054         else if (p[-3]|(p[-1]-1)) p++;
4055         else {
4056             p++;
4057             break;
4058         }
4059     }
4060
4061     p = FFMIN(p, end) - 4;
4062     *state = AV_RB32(p);
4063
4064     return p + 4;
4065 }
4066
4067 AVCPBProperties *av_cpb_properties_alloc(size_t *size)
4068 {
4069     AVCPBProperties *props = av_mallocz(sizeof(AVCPBProperties));
4070     if (!props)
4071         return NULL;
4072
4073     if (size)
4074         *size = sizeof(*props);
4075
4076     props->vbv_delay = UINT64_MAX;
4077
4078     return props;
4079 }
4080
4081 AVCPBProperties *ff_add_cpb_side_data(AVCodecContext *avctx)
4082 {
4083     AVPacketSideData *tmp;
4084     AVCPBProperties  *props;
4085     size_t size;
4086
4087     props = av_cpb_properties_alloc(&size);
4088     if (!props)
4089         return NULL;
4090
4091     tmp = av_realloc_array(avctx->coded_side_data, avctx->nb_coded_side_data + 1, sizeof(*tmp));
4092     if (!tmp) {
4093         av_freep(&props);
4094         return NULL;
4095     }
4096
4097     avctx->coded_side_data = tmp;
4098     avctx->nb_coded_side_data++;
4099
4100     avctx->coded_side_data[avctx->nb_coded_side_data - 1].type = AV_PKT_DATA_CPB_PROPERTIES;
4101     avctx->coded_side_data[avctx->nb_coded_side_data - 1].data = (uint8_t*)props;
4102     avctx->coded_side_data[avctx->nb_coded_side_data - 1].size = size;
4103
4104     return props;
4105 }
4106
4107 static void codec_parameters_reset(AVCodecParameters *par)
4108 {
4109     av_freep(&par->extradata);
4110
4111     memset(par, 0, sizeof(*par));
4112
4113     par->codec_type          = AVMEDIA_TYPE_UNKNOWN;
4114     par->codec_id            = AV_CODEC_ID_NONE;
4115     par->format              = -1;
4116     par->field_order         = AV_FIELD_UNKNOWN;
4117     par->color_range         = AVCOL_RANGE_UNSPECIFIED;
4118     par->color_primaries     = AVCOL_PRI_UNSPECIFIED;
4119     par->color_trc           = AVCOL_TRC_UNSPECIFIED;
4120     par->color_space         = AVCOL_SPC_UNSPECIFIED;
4121     par->chroma_location     = AVCHROMA_LOC_UNSPECIFIED;
4122     par->sample_aspect_ratio = (AVRational){ 0, 1 };
4123     par->profile             = FF_PROFILE_UNKNOWN;
4124     par->level               = FF_LEVEL_UNKNOWN;
4125 }
4126
4127 AVCodecParameters *avcodec_parameters_alloc(void)
4128 {
4129     AVCodecParameters *par = av_mallocz(sizeof(*par));
4130
4131     if (!par)
4132         return NULL;
4133     codec_parameters_reset(par);
4134     return par;
4135 }
4136
4137 void avcodec_parameters_free(AVCodecParameters **ppar)
4138 {
4139     AVCodecParameters *par = *ppar;
4140
4141     if (!par)
4142         return;
4143     codec_parameters_reset(par);
4144
4145     av_freep(ppar);
4146 }
4147
4148 int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
4149 {
4150     codec_parameters_reset(dst);
4151     memcpy(dst, src, sizeof(*dst));
4152
4153     dst->extradata      = NULL;
4154     dst->extradata_size = 0;
4155     if (src->extradata) {
4156         dst->extradata = av_mallocz(src->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
4157         if (!dst->extradata)
4158             return AVERROR(ENOMEM);
4159         memcpy(dst->extradata, src->extradata, src->extradata_size);
4160         dst->extradata_size = src->extradata_size;
4161     }
4162
4163     return 0;
4164 }
4165
4166 int avcodec_parameters_from_context(AVCodecParameters *par,
4167                                     const AVCodecContext *codec)
4168 {
4169     codec_parameters_reset(par);
4170
4171     par->codec_type = codec->codec_type;
4172     par->codec_id   = codec->codec_id;
4173     par->codec_tag  = codec->codec_tag;
4174
4175     par->bit_rate              = codec->bit_rate;
4176     par->bits_per_coded_sample = codec->bits_per_coded_sample;
4177     par->bits_per_raw_sample   = codec->bits_per_raw_sample;
4178     par->profile               = codec->profile;
4179     par->level                 = codec->level;
4180
4181     switch (par->codec_type) {
4182     case AVMEDIA_TYPE_VIDEO:
4183         par->format              = codec->pix_fmt;
4184         par->width               = codec->width;
4185         par->height              = codec->height;
4186         par->field_order         = codec->field_order;
4187         par->color_range         = codec->color_range;
4188         par->color_primaries     = codec->color_primaries;
4189         par->color_trc           = codec->color_trc;
4190         par->color_space         = codec->colorspace;
4191         par->chroma_location     = codec->chroma_sample_location;
4192         par->sample_aspect_ratio = codec->sample_aspect_ratio;
4193         par->video_delay         = codec->has_b_frames;
4194         break;
4195     case AVMEDIA_TYPE_AUDIO:
4196         par->format           = codec->sample_fmt;
4197         par->channel_layout   = codec->channel_layout;
4198         par->channels         = codec->channels;
4199         par->sample_rate      = codec->sample_rate;
4200         par->block_align      = codec->block_align;
4201         par->frame_size       = codec->frame_size;
4202         par->initial_padding  = codec->initial_padding;
4203         par->trailing_padding = codec->trailing_padding;
4204         par->seek_preroll     = codec->seek_preroll;
4205         break;
4206     case AVMEDIA_TYPE_SUBTITLE:
4207         par->width  = codec->width;
4208         par->height = codec->height;
4209         break;
4210     }
4211
4212     if (codec->extradata) {
4213         par->extradata = av_mallocz(codec->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
4214         if (!par->extradata)
4215             return AVERROR(ENOMEM);
4216         memcpy(par->extradata, codec->extradata, codec->extradata_size);
4217         par->extradata_size = codec->extradata_size;
4218     }
4219
4220     return 0;
4221 }
4222
4223 int avcodec_parameters_to_context(AVCodecContext *codec,
4224                                   const AVCodecParameters *par)
4225 {
4226     codec->codec_type = par->codec_type;
4227     codec->codec_id   = par->codec_id;
4228     codec->codec_tag  = par->codec_tag;
4229
4230     codec->bit_rate              = par->bit_rate;
4231     codec->bits_per_coded_sample = par->bits_per_coded_sample;
4232     codec->bits_per_raw_sample   = par->bits_per_raw_sample;
4233     codec->profile               = par->profile;
4234     codec->level                 = par->level;
4235
4236     switch (par->codec_type) {
4237     case AVMEDIA_TYPE_VIDEO:
4238         codec->pix_fmt                = par->format;
4239         codec->width                  = par->width;
4240         codec->height                 = par->height;
4241         codec->field_order            = par->field_order;
4242         codec->color_range            = par->color_range;
4243         codec->color_primaries        = par->color_primaries;
4244         codec->color_trc              = par->color_trc;
4245         codec->colorspace             = par->color_space;
4246         codec->chroma_sample_location = par->chroma_location;
4247         codec->sample_aspect_ratio    = par->sample_aspect_ratio;
4248         codec->has_b_frames           = par->video_delay;
4249         break;
4250     case AVMEDIA_TYPE_AUDIO:
4251         codec->sample_fmt       = par->format;
4252         codec->channel_layout   = par->channel_layout;
4253         codec->channels         = par->channels;
4254         codec->sample_rate      = par->sample_rate;
4255         codec->block_align      = par->block_align;
4256         codec->frame_size       = par->frame_size;
4257         codec->delay            =
4258         codec->initial_padding  = par->initial_padding;
4259         codec->trailing_padding = par->trailing_padding;
4260         codec->seek_preroll     = par->seek_preroll;
4261         break;
4262     case AVMEDIA_TYPE_SUBTITLE:
4263         codec->width  = par->width;
4264         codec->height = par->height;
4265         break;
4266     }
4267
4268     if (par->extradata) {
4269         av_freep(&codec->extradata);
4270         codec->extradata = av_mallocz(par->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
4271         if (!codec->extradata)
4272             return AVERROR(ENOMEM);
4273         memcpy(codec->extradata, par->extradata, par->extradata_size);
4274         codec->extradata_size = par->extradata_size;
4275     }
4276
4277     return 0;
4278 }
4279
4280 int ff_alloc_a53_sei(const AVFrame *frame, size_t prefix_len,
4281                      void **data, size_t *sei_size)
4282 {
4283     AVFrameSideData *side_data = NULL;
4284     uint8_t *sei_data;
4285
4286     if (frame)
4287         side_data = av_frame_get_side_data(frame, AV_FRAME_DATA_A53_CC);
4288
4289     if (!side_data) {
4290         *data = NULL;
4291         return 0;
4292     }
4293
4294     *sei_size = side_data->size + 11;
4295     *data = av_mallocz(*sei_size + prefix_len);
4296     if (!*data)
4297         return AVERROR(ENOMEM);
4298     sei_data = (uint8_t*)*data + prefix_len;
4299
4300     // country code
4301     sei_data[0] = 181;
4302     sei_data[1] = 0;
4303     sei_data[2] = 49;
4304