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