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