lavc: Add device context field to AVCodecContext
[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 Libav.
7  *
8  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22
23 /**
24  * @file
25  * utils.
26  */
27
28 #include "config.h"
29 #include "libavutil/attributes.h"
30 #include "libavutil/avassert.h"
31 #include "libavutil/avstring.h"
32 #include "libavutil/channel_layout.h"
33 #include "libavutil/crc.h"
34 #include "libavutil/frame.h"
35 #include "libavutil/hwcontext.h"
36 #include "libavutil/internal.h"
37 #include "libavutil/mathematics.h"
38 #include "libavutil/pixdesc.h"
39 #include "libavutil/imgutils.h"
40 #include "libavutil/samplefmt.h"
41 #include "libavutil/dict.h"
42 #include "avcodec.h"
43 #include "decode.h"
44 #include "libavutil/opt.h"
45 #include "me_cmp.h"
46 #include "mpegvideo.h"
47 #include "thread.h"
48 #include "internal.h"
49 #include "bytestream.h"
50 #include "version.h"
51 #include <stdlib.h>
52 #include <stdarg.h>
53 #include <limits.h>
54 #include <float.h>
55
56 static int volatile entangled_thread_counter = 0;
57 static int (*lockmgr_cb)(void **mutex, enum AVLockOp op);
58 static void *codec_mutex;
59 static void *avformat_mutex;
60
61 void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
62 {
63     void **p = ptr;
64     if (min_size > SIZE_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
65         av_freep(p);
66         *size = 0;
67         return;
68     }
69     av_fast_malloc(p, size, min_size + AV_INPUT_BUFFER_PADDING_SIZE);
70     if (*size)
71         memset((uint8_t *)*p + min_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
72 }
73
74 /* encoder management */
75 static AVCodec *first_avcodec = NULL;
76
77 AVCodec *av_codec_next(const AVCodec *c)
78 {
79     if (c)
80         return c->next;
81     else
82         return first_avcodec;
83 }
84
85 static av_cold void avcodec_init(void)
86 {
87     static int initialized = 0;
88
89     if (initialized != 0)
90         return;
91     initialized = 1;
92
93     if (CONFIG_ME_CMP)
94         ff_me_cmp_init_static();
95 }
96
97 int av_codec_is_encoder(const AVCodec *codec)
98 {
99     return codec && (codec->encode_sub || codec->encode2 ||codec->send_frame);
100 }
101
102 int av_codec_is_decoder(const AVCodec *codec)
103 {
104     return codec && (codec->decode || codec->receive_frame);
105 }
106
107 av_cold void avcodec_register(AVCodec *codec)
108 {
109     AVCodec **p;
110     avcodec_init();
111     p = &first_avcodec;
112     while (*p)
113         p = &(*p)->next;
114     *p          = codec;
115     codec->next = NULL;
116
117     if (codec->init_static_data)
118         codec->init_static_data(codec);
119 }
120
121 #if FF_API_EMU_EDGE
122 unsigned avcodec_get_edge_width(void)
123 {
124     return EDGE_WIDTH;
125 }
126 #endif
127
128 #if FF_API_SET_DIMENSIONS
129 void avcodec_set_dimensions(AVCodecContext *s, int width, int height)
130 {
131     ff_set_dimensions(s, width, height);
132 }
133 #endif
134
135 int ff_set_dimensions(AVCodecContext *s, int width, int height)
136 {
137     int ret = av_image_check_size(width, height, 0, s);
138
139     if (ret < 0)
140         width = height = 0;
141     s->width  = s->coded_width  = width;
142     s->height = s->coded_height = height;
143
144     return ret;
145 }
146
147 int ff_set_sar(AVCodecContext *avctx, AVRational sar)
148 {
149     int ret = av_image_check_sar(avctx->width, avctx->height, sar);
150
151     if (ret < 0) {
152         av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %d/%d\n",
153                sar.num, sar.den);
154         avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
155         return ret;
156     } else {
157         avctx->sample_aspect_ratio = sar;
158     }
159     return 0;
160 }
161
162 int ff_side_data_update_matrix_encoding(AVFrame *frame,
163                                         enum AVMatrixEncoding matrix_encoding)
164 {
165     AVFrameSideData *side_data;
166     enum AVMatrixEncoding *data;
167
168     side_data = av_frame_get_side_data(frame, AV_FRAME_DATA_MATRIXENCODING);
169     if (!side_data)
170         side_data = av_frame_new_side_data(frame, AV_FRAME_DATA_MATRIXENCODING,
171                                            sizeof(enum AVMatrixEncoding));
172
173     if (!side_data)
174         return AVERROR(ENOMEM);
175
176     data  = (enum AVMatrixEncoding*)side_data->data;
177     *data = matrix_encoding;
178
179     return 0;
180 }
181
182 void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height,
183                                int linesize_align[AV_NUM_DATA_POINTERS])
184 {
185     size_t max_align = av_cpu_max_align();
186     int i;
187     int w_align = 1;
188     int h_align = 1;
189
190     switch (s->pix_fmt) {
191     case AV_PIX_FMT_YUV420P:
192     case AV_PIX_FMT_YUYV422:
193     case AV_PIX_FMT_YVYU422:
194     case AV_PIX_FMT_UYVY422:
195     case AV_PIX_FMT_YUV422P:
196     case AV_PIX_FMT_YUV440P:
197     case AV_PIX_FMT_YUV444P:
198     case AV_PIX_FMT_GBRP:
199     case AV_PIX_FMT_GBRAP:
200     case AV_PIX_FMT_GRAY8:
201     case AV_PIX_FMT_GRAY16BE:
202     case AV_PIX_FMT_GRAY16LE:
203     case AV_PIX_FMT_YUVJ420P:
204     case AV_PIX_FMT_YUVJ422P:
205     case AV_PIX_FMT_YUVJ440P:
206     case AV_PIX_FMT_YUVJ444P:
207     case AV_PIX_FMT_YUVA420P:
208     case AV_PIX_FMT_YUVA422P:
209     case AV_PIX_FMT_YUVA444P:
210     case AV_PIX_FMT_YUV420P9LE:
211     case AV_PIX_FMT_YUV420P9BE:
212     case AV_PIX_FMT_YUV420P10LE:
213     case AV_PIX_FMT_YUV420P10BE:
214     case AV_PIX_FMT_YUV422P9LE:
215     case AV_PIX_FMT_YUV422P9BE:
216     case AV_PIX_FMT_YUV422P10LE:
217     case AV_PIX_FMT_YUV422P10BE:
218     case AV_PIX_FMT_YUVA422P10LE:
219     case AV_PIX_FMT_YUVA422P10BE:
220     case AV_PIX_FMT_YUV444P9LE:
221     case AV_PIX_FMT_YUV444P9BE:
222     case AV_PIX_FMT_YUV444P10LE:
223     case AV_PIX_FMT_YUV444P10BE:
224     case AV_PIX_FMT_YUVA444P10LE:
225     case AV_PIX_FMT_YUVA444P10BE:
226     case AV_PIX_FMT_GBRP9LE:
227     case AV_PIX_FMT_GBRP9BE:
228     case AV_PIX_FMT_GBRP10LE:
229     case AV_PIX_FMT_GBRP10BE:
230     case AV_PIX_FMT_GBRAP12LE:
231     case AV_PIX_FMT_GBRAP12BE:
232         w_align = 16; //FIXME assume 16 pixel per macroblock
233         h_align = 16 * 2; // interlaced needs 2 macroblocks height
234         break;
235     case AV_PIX_FMT_YUV411P:
236     case AV_PIX_FMT_UYYVYY411:
237         w_align = 32;
238         h_align = 8;
239         break;
240     case AV_PIX_FMT_YUV410P:
241         if (s->codec_id == AV_CODEC_ID_SVQ1) {
242             w_align = 64;
243             h_align = 64;
244         }
245     case AV_PIX_FMT_RGB555:
246         if (s->codec_id == AV_CODEC_ID_RPZA) {
247             w_align = 4;
248             h_align = 4;
249         }
250     case AV_PIX_FMT_PAL8:
251     case AV_PIX_FMT_BGR8:
252     case AV_PIX_FMT_RGB8:
253         if (s->codec_id == AV_CODEC_ID_SMC) {
254             w_align = 4;
255             h_align = 4;
256         }
257         break;
258     case AV_PIX_FMT_BGR24:
259         if ((s->codec_id == AV_CODEC_ID_MSZH) ||
260             (s->codec_id == AV_CODEC_ID_ZLIB)) {
261             w_align = 4;
262             h_align = 4;
263         }
264         break;
265     default:
266         w_align = 1;
267         h_align = 1;
268         break;
269     }
270
271     *width  = FFALIGN(*width, w_align);
272     *height = FFALIGN(*height, h_align);
273     if (s->codec_id == AV_CODEC_ID_H264)
274         // some of the optimized chroma MC reads one line too much
275         *height += 2;
276
277     for (i = 0; i < 4; i++)
278         linesize_align[i] = max_align;
279 }
280
281 void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height)
282 {
283     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->pix_fmt);
284     int chroma_shift = desc->log2_chroma_w;
285     int linesize_align[AV_NUM_DATA_POINTERS];
286     int align;
287
288     avcodec_align_dimensions2(s, width, height, linesize_align);
289     align               = FFMAX(linesize_align[0], linesize_align[3]);
290     linesize_align[1] <<= chroma_shift;
291     linesize_align[2] <<= chroma_shift;
292     align               = FFMAX3(align, linesize_align[1], linesize_align[2]);
293     *width              = FFALIGN(*width, align);
294 }
295
296 int avcodec_fill_audio_frame(AVFrame *frame, int nb_channels,
297                              enum AVSampleFormat sample_fmt, const uint8_t *buf,
298                              int buf_size, int align)
299 {
300     int ch, planar, needed_size, ret = 0;
301
302     needed_size = av_samples_get_buffer_size(NULL, nb_channels,
303                                              frame->nb_samples, sample_fmt,
304                                              align);
305     if (buf_size < needed_size)
306         return AVERROR(EINVAL);
307
308     planar = av_sample_fmt_is_planar(sample_fmt);
309     if (planar && nb_channels > AV_NUM_DATA_POINTERS) {
310         if (!(frame->extended_data = av_mallocz(nb_channels *
311                                                 sizeof(*frame->extended_data))))
312             return AVERROR(ENOMEM);
313     } else {
314         frame->extended_data = frame->data;
315     }
316
317     if ((ret = av_samples_fill_arrays(frame->extended_data, &frame->linesize[0],
318                                       buf, nb_channels, frame->nb_samples,
319                                       sample_fmt, align)) < 0) {
320         if (frame->extended_data != frame->data)
321             av_free(frame->extended_data);
322         return ret;
323     }
324     if (frame->extended_data != frame->data) {
325         for (ch = 0; ch < AV_NUM_DATA_POINTERS; ch++)
326             frame->data[ch] = frame->extended_data[ch];
327     }
328
329     return ret;
330 }
331
332 int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2), void *arg, int *ret, int count, int size)
333 {
334     int i;
335
336     for (i = 0; i < count; i++) {
337         int r = func(c, (char *)arg + i * size);
338         if (ret)
339             ret[i] = r;
340     }
341     return 0;
342 }
343
344 int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int jobnr, int threadnr), void *arg, int *ret, int count)
345 {
346     int i;
347
348     for (i = 0; i < count; i++) {
349         int r = func(c, arg, i, 0);
350         if (ret)
351             ret[i] = r;
352     }
353     return 0;
354 }
355
356 int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
357 {
358     int ret = 0;
359     AVDictionary *tmp = NULL;
360
361     if (avcodec_is_open(avctx))
362         return 0;
363
364     if ((!codec && !avctx->codec)) {
365         av_log(avctx, AV_LOG_ERROR, "No codec provided to avcodec_open2().\n");
366         return AVERROR(EINVAL);
367     }
368     if ((codec && avctx->codec && codec != avctx->codec)) {
369         av_log(avctx, AV_LOG_ERROR, "This AVCodecContext was allocated for %s, "
370                                     "but %s passed to avcodec_open2().\n", avctx->codec->name, codec->name);
371         return AVERROR(EINVAL);
372     }
373     if (!codec)
374         codec = avctx->codec;
375
376     if (avctx->extradata_size < 0 || avctx->extradata_size >= FF_MAX_EXTRADATA_SIZE)
377         return AVERROR(EINVAL);
378
379     if (options)
380         av_dict_copy(&tmp, *options, 0);
381
382     /* If there is a user-supplied mutex locking routine, call it. */
383     if (!(codec->caps_internal & FF_CODEC_CAP_INIT_THREADSAFE) && codec->init) {
384         if (lockmgr_cb) {
385             if ((*lockmgr_cb)(&codec_mutex, AV_LOCK_OBTAIN))
386                 return -1;
387         }
388
389         entangled_thread_counter++;
390         if (entangled_thread_counter != 1) {
391             av_log(avctx, AV_LOG_ERROR,
392                    "Insufficient thread locking. At least %d threads are "
393                    "calling avcodec_open2() at the same time right now.\n",
394                    entangled_thread_counter);
395             ret = -1;
396             goto end;
397         }
398     }
399
400     avctx->internal = av_mallocz(sizeof(AVCodecInternal));
401     if (!avctx->internal) {
402         ret = AVERROR(ENOMEM);
403         goto end;
404     }
405
406     avctx->internal->pool = av_mallocz(sizeof(*avctx->internal->pool));
407     if (!avctx->internal->pool) {
408         ret = AVERROR(ENOMEM);
409         goto free_and_end;
410     }
411
412     avctx->internal->to_free = av_frame_alloc();
413     if (!avctx->internal->to_free) {
414         ret = AVERROR(ENOMEM);
415         goto free_and_end;
416     }
417
418     avctx->internal->compat_decode_frame = av_frame_alloc();
419     if (!avctx->internal->compat_decode_frame) {
420         ret = AVERROR(ENOMEM);
421         goto free_and_end;
422     }
423
424     avctx->internal->buffer_frame = av_frame_alloc();
425     if (!avctx->internal->buffer_frame) {
426         ret = AVERROR(ENOMEM);
427         goto free_and_end;
428     }
429
430     avctx->internal->buffer_pkt = av_packet_alloc();
431     if (!avctx->internal->buffer_pkt) {
432         ret = AVERROR(ENOMEM);
433         goto free_and_end;
434     }
435
436     avctx->internal->ds.in_pkt = av_packet_alloc();
437     if (!avctx->internal->ds.in_pkt) {
438         ret = AVERROR(ENOMEM);
439         goto free_and_end;
440     }
441
442     avctx->internal->last_pkt_props = av_packet_alloc();
443     if (!avctx->internal->last_pkt_props) {
444         ret = AVERROR(ENOMEM);
445         goto free_and_end;
446     }
447
448     if (codec->priv_data_size > 0) {
449         if (!avctx->priv_data) {
450             avctx->priv_data = av_mallocz(codec->priv_data_size);
451             if (!avctx->priv_data) {
452                 ret = AVERROR(ENOMEM);
453                 goto end;
454             }
455             if (codec->priv_class) {
456                 *(const AVClass **)avctx->priv_data = codec->priv_class;
457                 av_opt_set_defaults(avctx->priv_data);
458             }
459         }
460         if (codec->priv_class && (ret = av_opt_set_dict(avctx->priv_data, &tmp)) < 0)
461             goto free_and_end;
462     } else {
463         avctx->priv_data = NULL;
464     }
465     if ((ret = av_opt_set_dict(avctx, &tmp)) < 0)
466         goto free_and_end;
467
468     if (avctx->coded_width && avctx->coded_height && !avctx->width && !avctx->height)
469         ret = ff_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);
470     else if (avctx->width && avctx->height)
471         ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
472     if (ret < 0)
473         goto free_and_end;
474
475     if ((avctx->coded_width || avctx->coded_height || avctx->width || avctx->height)
476         && (  av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx) < 0
477            || av_image_check_size(avctx->width,       avctx->height,       0, avctx) < 0)) {
478         av_log(avctx, AV_LOG_WARNING, "ignoring invalid width/height values\n");
479         ff_set_dimensions(avctx, 0, 0);
480     }
481
482     if (avctx->width > 0 && avctx->height > 0) {
483         if (av_image_check_sar(avctx->width, avctx->height,
484                                avctx->sample_aspect_ratio) < 0) {
485             av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
486                    avctx->sample_aspect_ratio.num,
487                    avctx->sample_aspect_ratio.den);
488             avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
489         }
490     }
491
492     /* if the decoder init function was already called previously,
493      * free the already allocated subtitle_header before overwriting it */
494     if (av_codec_is_decoder(codec))
495         av_freep(&avctx->subtitle_header);
496
497     if (avctx->channels > FF_SANE_NB_CHANNELS) {
498         ret = AVERROR(EINVAL);
499         goto free_and_end;
500     }
501
502     avctx->codec = codec;
503     if ((avctx->codec_type == AVMEDIA_TYPE_UNKNOWN || avctx->codec_type == codec->type) &&
504         avctx->codec_id == AV_CODEC_ID_NONE) {
505         avctx->codec_type = codec->type;
506         avctx->codec_id   = codec->id;
507     }
508     if (avctx->codec_id != codec->id || (avctx->codec_type != codec->type
509                                          && avctx->codec_type != AVMEDIA_TYPE_ATTACHMENT)) {
510         av_log(avctx, AV_LOG_ERROR, "codec type or id mismatches\n");
511         ret = AVERROR(EINVAL);
512         goto free_and_end;
513     }
514     avctx->frame_number = 0;
515
516     if ((avctx->codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL) &&
517         avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
518         ret = AVERROR_EXPERIMENTAL;
519         goto free_and_end;
520     }
521
522     if (avctx->codec_type == AVMEDIA_TYPE_AUDIO &&
523         (!avctx->time_base.num || !avctx->time_base.den)) {
524         avctx->time_base.num = 1;
525         avctx->time_base.den = avctx->sample_rate;
526     }
527
528     if (HAVE_THREADS) {
529         ret = ff_thread_init(avctx);
530         if (ret < 0) {
531             goto free_and_end;
532         }
533     }
534     if (!HAVE_THREADS && !(codec->capabilities & AV_CODEC_CAP_AUTO_THREADS))
535         avctx->thread_count = 1;
536
537     if (av_codec_is_encoder(avctx->codec)) {
538         int i;
539 #if FF_API_CODED_FRAME
540 FF_DISABLE_DEPRECATION_WARNINGS
541         avctx->coded_frame = av_frame_alloc();
542         if (!avctx->coded_frame) {
543             ret = AVERROR(ENOMEM);
544             goto free_and_end;
545         }
546 FF_ENABLE_DEPRECATION_WARNINGS
547 #endif
548
549         if (avctx->time_base.num <= 0 || avctx->time_base.den <= 0) {
550             av_log(avctx, AV_LOG_ERROR, "The encoder timebase is not set.\n");
551             ret = AVERROR(EINVAL);
552             goto free_and_end;
553         }
554
555         if (avctx->codec->sample_fmts) {
556             for (i = 0; avctx->codec->sample_fmts[i] != AV_SAMPLE_FMT_NONE; i++) {
557                 if (avctx->sample_fmt == avctx->codec->sample_fmts[i])
558                     break;
559                 if (avctx->channels == 1 &&
560                     av_get_planar_sample_fmt(avctx->sample_fmt) ==
561                     av_get_planar_sample_fmt(avctx->codec->sample_fmts[i])) {
562                     avctx->sample_fmt = avctx->codec->sample_fmts[i];
563                     break;
564                 }
565             }
566             if (avctx->codec->sample_fmts[i] == AV_SAMPLE_FMT_NONE) {
567                 av_log(avctx, AV_LOG_ERROR, "Specified sample_fmt is not supported.\n");
568                 ret = AVERROR(EINVAL);
569                 goto free_and_end;
570             }
571         }
572         if (avctx->codec->pix_fmts) {
573             for (i = 0; avctx->codec->pix_fmts[i] != AV_PIX_FMT_NONE; i++)
574                 if (avctx->pix_fmt == avctx->codec->pix_fmts[i])
575                     break;
576             if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_NONE) {
577                 av_log(avctx, AV_LOG_ERROR, "Specified pix_fmt is not supported\n");
578                 ret = AVERROR(EINVAL);
579                 goto free_and_end;
580             }
581             if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ420P ||
582                 avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ422P ||
583                 avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ440P ||
584                 avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ444P)
585                 avctx->color_range = AVCOL_RANGE_JPEG;
586         }
587         if (avctx->codec->supported_samplerates) {
588             for (i = 0; avctx->codec->supported_samplerates[i] != 0; i++)
589                 if (avctx->sample_rate == avctx->codec->supported_samplerates[i])
590                     break;
591             if (avctx->codec->supported_samplerates[i] == 0) {
592                 av_log(avctx, AV_LOG_ERROR, "Specified sample_rate is not supported\n");
593                 ret = AVERROR(EINVAL);
594                 goto free_and_end;
595             }
596         }
597         if (avctx->codec->channel_layouts) {
598             if (!avctx->channel_layout) {
599                 av_log(avctx, AV_LOG_WARNING, "channel_layout not specified\n");
600             } else {
601                 for (i = 0; avctx->codec->channel_layouts[i] != 0; i++)
602                     if (avctx->channel_layout == avctx->codec->channel_layouts[i])
603                         break;
604                 if (avctx->codec->channel_layouts[i] == 0) {
605                     av_log(avctx, AV_LOG_ERROR, "Specified channel_layout is not supported\n");
606                     ret = AVERROR(EINVAL);
607                     goto free_and_end;
608                 }
609             }
610         }
611         if (avctx->channel_layout && avctx->channels) {
612             if (av_get_channel_layout_nb_channels(avctx->channel_layout) != avctx->channels) {
613                 av_log(avctx, AV_LOG_ERROR, "channel layout does not match number of channels\n");
614                 ret = AVERROR(EINVAL);
615                 goto free_and_end;
616             }
617         } else if (avctx->channel_layout) {
618             avctx->channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
619         }
620
621         if (!avctx->rc_initial_buffer_occupancy)
622             avctx->rc_initial_buffer_occupancy = avctx->rc_buffer_size * 3 / 4;
623
624         if (avctx->ticks_per_frame &&
625             avctx->ticks_per_frame > INT_MAX / avctx->time_base.num) {
626             av_log(avctx, AV_LOG_ERROR,
627                    "ticks_per_frame %d too large for the timebase %d/%d.",
628                    avctx->ticks_per_frame,
629                    avctx->time_base.num,
630                    avctx->time_base.den);
631             goto free_and_end;
632         }
633
634         if (avctx->hw_frames_ctx) {
635             AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
636             if (frames_ctx->format != avctx->pix_fmt) {
637                 av_log(avctx, AV_LOG_ERROR,
638                        "Mismatching AVCodecContext.pix_fmt and AVHWFramesContext.format\n");
639                 ret = AVERROR(EINVAL);
640                 goto free_and_end;
641             }
642             if (avctx->sw_pix_fmt != AV_PIX_FMT_NONE &&
643                 avctx->sw_pix_fmt != frames_ctx->sw_format) {
644                 av_log(avctx, AV_LOG_ERROR,
645                        "Mismatching AVCodecContext.sw_pix_fmt (%s) "
646                        "and AVHWFramesContext.sw_format (%s)\n",
647                        av_get_pix_fmt_name(avctx->sw_pix_fmt),
648                        av_get_pix_fmt_name(frames_ctx->sw_format));
649                 ret = AVERROR(EINVAL);
650                 goto free_and_end;
651             }
652             avctx->sw_pix_fmt = frames_ctx->sw_format;
653         }
654     }
655
656     if (avctx->codec->init && !(avctx->active_thread_type & FF_THREAD_FRAME)) {
657         ret = avctx->codec->init(avctx);
658         if (ret < 0) {
659             goto free_and_end;
660         }
661     }
662
663 #if FF_API_AUDIOENC_DELAY
664     if (av_codec_is_encoder(avctx->codec))
665         avctx->delay = avctx->initial_padding;
666 #endif
667
668     if (av_codec_is_decoder(avctx->codec)) {
669         /* validate channel layout from the decoder */
670         if (avctx->channel_layout) {
671             int channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
672             if (!avctx->channels)
673                 avctx->channels = channels;
674             else if (channels != avctx->channels) {
675                 av_log(avctx, AV_LOG_WARNING,
676                        "channel layout does not match number of channels\n");
677                 avctx->channel_layout = 0;
678             }
679         }
680         if (avctx->channels && avctx->channels < 0 ||
681             avctx->channels > FF_SANE_NB_CHANNELS) {
682             ret = AVERROR(EINVAL);
683             goto free_and_end;
684         }
685
686 #if FF_API_AVCTX_TIMEBASE
687         if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
688             avctx->time_base = av_inv_q(avctx->framerate);
689 #endif
690     }
691 end:
692     if (!(codec->caps_internal & FF_CODEC_CAP_INIT_THREADSAFE) && codec->init) {
693         entangled_thread_counter--;
694
695         /* Release any user-supplied mutex. */
696         if (lockmgr_cb) {
697             (*lockmgr_cb)(&codec_mutex, AV_LOCK_RELEASE);
698         }
699     }
700
701     if (options) {
702         av_dict_free(options);
703         *options = tmp;
704     }
705
706     return ret;
707 free_and_end:
708     if (avctx->codec &&
709         (avctx->codec->caps_internal & FF_CODEC_CAP_INIT_CLEANUP))
710         avctx->codec->close(avctx);
711
712     if (avctx->priv_data && avctx->codec && avctx->codec->priv_class)
713         av_opt_free(avctx->priv_data);
714     av_opt_free(avctx);
715
716 #if FF_API_CODED_FRAME
717 FF_DISABLE_DEPRECATION_WARNINGS
718     av_frame_free(&avctx->coded_frame);
719 FF_ENABLE_DEPRECATION_WARNINGS
720 #endif
721
722     av_dict_free(&tmp);
723     av_freep(&avctx->priv_data);
724     if (avctx->internal) {
725         av_frame_free(&avctx->internal->to_free);
726         av_frame_free(&avctx->internal->compat_decode_frame);
727         av_frame_free(&avctx->internal->buffer_frame);
728         av_packet_free(&avctx->internal->buffer_pkt);
729         av_packet_free(&avctx->internal->last_pkt_props);
730
731         av_packet_free(&avctx->internal->ds.in_pkt);
732
733         av_freep(&avctx->internal->pool);
734     }
735     av_freep(&avctx->internal);
736     avctx->codec = NULL;
737     goto end;
738 }
739
740 void avsubtitle_free(AVSubtitle *sub)
741 {
742     int i;
743
744     for (i = 0; i < sub->num_rects; i++) {
745         av_freep(&sub->rects[i]->data[0]);
746         av_freep(&sub->rects[i]->data[1]);
747         av_freep(&sub->rects[i]->data[2]);
748         av_freep(&sub->rects[i]->data[3]);
749         av_freep(&sub->rects[i]->text);
750         av_freep(&sub->rects[i]->ass);
751         av_freep(&sub->rects[i]);
752     }
753
754     av_freep(&sub->rects);
755
756     memset(sub, 0, sizeof(AVSubtitle));
757 }
758
759 av_cold int avcodec_close(AVCodecContext *avctx)
760 {
761     int i;
762
763     if (avcodec_is_open(avctx)) {
764         FramePool *pool = avctx->internal->pool;
765
766         if (HAVE_THREADS && avctx->internal->thread_ctx)
767             ff_thread_free(avctx);
768         if (avctx->codec && avctx->codec->close)
769             avctx->codec->close(avctx);
770         av_frame_free(&avctx->internal->to_free);
771         av_frame_free(&avctx->internal->compat_decode_frame);
772         av_frame_free(&avctx->internal->buffer_frame);
773         av_packet_free(&avctx->internal->buffer_pkt);
774         av_packet_free(&avctx->internal->last_pkt_props);
775
776         av_packet_free(&avctx->internal->ds.in_pkt);
777
778         for (i = 0; i < FF_ARRAY_ELEMS(pool->pools); i++)
779             av_buffer_pool_uninit(&pool->pools[i]);
780         av_freep(&avctx->internal->pool);
781
782         if (avctx->hwaccel && avctx->hwaccel->uninit)
783             avctx->hwaccel->uninit(avctx);
784         av_freep(&avctx->internal->hwaccel_priv_data);
785
786         ff_decode_bsfs_uninit(avctx);
787
788         av_freep(&avctx->internal);
789     }
790
791     for (i = 0; i < avctx->nb_coded_side_data; i++)
792         av_freep(&avctx->coded_side_data[i].data);
793     av_freep(&avctx->coded_side_data);
794     avctx->nb_coded_side_data = 0;
795
796     av_buffer_unref(&avctx->hw_frames_ctx);
797     av_buffer_unref(&avctx->hw_device_ctx);
798
799     if (avctx->priv_data && avctx->codec && avctx->codec->priv_class)
800         av_opt_free(avctx->priv_data);
801     av_opt_free(avctx);
802     av_freep(&avctx->priv_data);
803     if (av_codec_is_encoder(avctx->codec)) {
804         av_freep(&avctx->extradata);
805 #if FF_API_CODED_FRAME
806 FF_DISABLE_DEPRECATION_WARNINGS
807         av_frame_free(&avctx->coded_frame);
808 FF_ENABLE_DEPRECATION_WARNINGS
809 #endif
810     }
811     avctx->codec = NULL;
812     avctx->active_thread_type = 0;
813
814     return 0;
815 }
816
817 static AVCodec *find_encdec(enum AVCodecID id, int encoder)
818 {
819     AVCodec *p, *experimental = NULL;
820     p = first_avcodec;
821     while (p) {
822         if ((encoder ? av_codec_is_encoder(p) : av_codec_is_decoder(p)) &&
823             p->id == id) {
824             if (p->capabilities & AV_CODEC_CAP_EXPERIMENTAL && !experimental) {
825                 experimental = p;
826             } else
827                 return p;
828         }
829         p = p->next;
830     }
831     return experimental;
832 }
833
834 AVCodec *avcodec_find_encoder(enum AVCodecID id)
835 {
836     return find_encdec(id, 1);
837 }
838
839 AVCodec *avcodec_find_encoder_by_name(const char *name)
840 {
841     AVCodec *p;
842     if (!name)
843         return NULL;
844     p = first_avcodec;
845     while (p) {
846         if (av_codec_is_encoder(p) && strcmp(name, p->name) == 0)
847             return p;
848         p = p->next;
849     }
850     return NULL;
851 }
852
853 AVCodec *avcodec_find_decoder(enum AVCodecID id)
854 {
855     return find_encdec(id, 0);
856 }
857
858 AVCodec *avcodec_find_decoder_by_name(const char *name)
859 {
860     AVCodec *p;
861     if (!name)
862         return NULL;
863     p = first_avcodec;
864     while (p) {
865         if (av_codec_is_decoder(p) && strcmp(name, p->name) == 0)
866             return p;
867         p = p->next;
868     }
869     return NULL;
870 }
871
872 static int get_bit_rate(AVCodecContext *ctx)
873 {
874     int bit_rate;
875     int bits_per_sample;
876
877     switch (ctx->codec_type) {
878     case AVMEDIA_TYPE_VIDEO:
879     case AVMEDIA_TYPE_DATA:
880     case AVMEDIA_TYPE_SUBTITLE:
881     case AVMEDIA_TYPE_ATTACHMENT:
882         bit_rate = ctx->bit_rate;
883         break;
884     case AVMEDIA_TYPE_AUDIO:
885         bits_per_sample = av_get_bits_per_sample(ctx->codec_id);
886         bit_rate = bits_per_sample ? ctx->sample_rate * ctx->channels * bits_per_sample : ctx->bit_rate;
887         break;
888     default:
889         bit_rate = 0;
890         break;
891     }
892     return bit_rate;
893 }
894
895 size_t av_get_codec_tag_string(char *buf, size_t buf_size, unsigned int codec_tag)
896 {
897     int i, len, ret = 0;
898
899 #define TAG_PRINT(x)                                              \
900     (((x) >= '0' && (x) <= '9') ||                                \
901      ((x) >= 'a' && (x) <= 'z') || ((x) >= 'A' && (x) <= 'Z') ||  \
902      ((x) == '.' || (x) == ' '))
903
904     for (i = 0; i < 4; i++) {
905         len = snprintf(buf, buf_size,
906                        TAG_PRINT(codec_tag & 0xFF) ? "%c" : "[%d]", codec_tag & 0xFF);
907         buf        += len;
908         buf_size    = buf_size > len ? buf_size - len : 0;
909         ret        += len;
910         codec_tag >>= 8;
911     }
912     return ret;
913 }
914
915 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
916 {
917     const char *codec_name;
918     const char *profile = NULL;
919     char buf1[32];
920     int bitrate;
921     int new_line = 0;
922     AVRational display_aspect_ratio;
923     const AVCodecDescriptor *desc = avcodec_descriptor_get(enc->codec_id);
924
925     if (desc) {
926         codec_name = desc->name;
927         profile = avcodec_profile_name(enc->codec_id, enc->profile);
928     } else if (enc->codec_id == AV_CODEC_ID_MPEG2TS) {
929         /* fake mpeg2 transport stream codec (currently not
930          * registered) */
931         codec_name = "mpeg2ts";
932     } else {
933         /* output avi tags */
934         char tag_buf[32];
935         av_get_codec_tag_string(tag_buf, sizeof(tag_buf), enc->codec_tag);
936         snprintf(buf1, sizeof(buf1), "%s / 0x%04X", tag_buf, enc->codec_tag);
937         codec_name = buf1;
938     }
939
940     switch (enc->codec_type) {
941     case AVMEDIA_TYPE_VIDEO:
942         snprintf(buf, buf_size,
943                  "Video: %s%s",
944                  codec_name, enc->mb_decision ? " (hq)" : "");
945         if (profile)
946             snprintf(buf + strlen(buf), buf_size - strlen(buf),
947                      " (%s)", profile);
948         if (enc->codec_tag) {
949             char tag_buf[32];
950             av_get_codec_tag_string(tag_buf, sizeof(tag_buf), enc->codec_tag);
951             snprintf(buf + strlen(buf), buf_size - strlen(buf),
952                      " [%s / 0x%04X]", tag_buf, enc->codec_tag);
953         }
954
955         av_strlcat(buf, "\n      ", buf_size);
956         snprintf(buf + strlen(buf), buf_size - strlen(buf),
957                  "%s", enc->pix_fmt == AV_PIX_FMT_NONE ? "none" :
958                      av_get_pix_fmt_name(enc->pix_fmt));
959
960         if (enc->color_range != AVCOL_RANGE_UNSPECIFIED)
961             snprintf(buf + strlen(buf), buf_size - strlen(buf), ", %s",
962                      av_color_range_name(enc->color_range));
963         if (enc->colorspace != AVCOL_SPC_UNSPECIFIED ||
964             enc->color_primaries != AVCOL_PRI_UNSPECIFIED ||
965             enc->color_trc != AVCOL_TRC_UNSPECIFIED) {
966             new_line = 1;
967             snprintf(buf + strlen(buf), buf_size - strlen(buf), ", %s/%s/%s",
968                      av_color_space_name(enc->colorspace),
969                      av_color_primaries_name(enc->color_primaries),
970                      av_color_transfer_name(enc->color_trc));
971         }
972         if (av_log_get_level() >= AV_LOG_DEBUG &&
973             enc->chroma_sample_location != AVCHROMA_LOC_UNSPECIFIED)
974             snprintf(buf + strlen(buf), buf_size - strlen(buf), ", %s",
975                      av_chroma_location_name(enc->chroma_sample_location));
976
977         if (enc->width) {
978             av_strlcat(buf, new_line ? "\n      " : ", ", buf_size);
979
980             snprintf(buf + strlen(buf), buf_size - strlen(buf),
981                      "%dx%d",
982                      enc->width, enc->height);
983
984             if (av_log_get_level() >= AV_LOG_VERBOSE &&
985                 (enc->width != enc->coded_width ||
986                  enc->height != enc->coded_height))
987                 snprintf(buf + strlen(buf), buf_size - strlen(buf),
988                          " (%dx%d)", enc->coded_width, enc->coded_height);
989
990             if (enc->sample_aspect_ratio.num) {
991                 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
992                           enc->width * enc->sample_aspect_ratio.num,
993                           enc->height * enc->sample_aspect_ratio.den,
994                           1024 * 1024);
995                 snprintf(buf + strlen(buf), buf_size - strlen(buf),
996                          " [PAR %d:%d DAR %d:%d]",
997                          enc->sample_aspect_ratio.num, enc->sample_aspect_ratio.den,
998                          display_aspect_ratio.num, display_aspect_ratio.den);
999             }
1000             if (av_log_get_level() >= AV_LOG_DEBUG) {
1001                 int g = av_gcd(enc->time_base.num, enc->time_base.den);
1002                 snprintf(buf + strlen(buf), buf_size - strlen(buf),
1003                          ", %d/%d",
1004                          enc->time_base.num / g, enc->time_base.den / g);
1005             }
1006         }
1007         if (encode) {
1008             snprintf(buf + strlen(buf), buf_size - strlen(buf),
1009                      ", q=%d-%d", enc->qmin, enc->qmax);
1010         }
1011         break;
1012     case AVMEDIA_TYPE_AUDIO:
1013         snprintf(buf, buf_size,
1014                  "Audio: %s",
1015                  codec_name);
1016         if (profile)
1017             snprintf(buf + strlen(buf), buf_size - strlen(buf),
1018                      " (%s)", profile);
1019         if (enc->codec_tag) {
1020             char tag_buf[32];
1021             av_get_codec_tag_string(tag_buf, sizeof(tag_buf), enc->codec_tag);
1022             snprintf(buf + strlen(buf), buf_size - strlen(buf),
1023                      " [%s / 0x%04X]", tag_buf, enc->codec_tag);
1024         }
1025
1026         av_strlcat(buf, "\n      ", buf_size);
1027         if (enc->sample_rate) {
1028             snprintf(buf + strlen(buf), buf_size - strlen(buf),
1029                      "%d Hz, ", enc->sample_rate);
1030         }
1031         av_get_channel_layout_string(buf + strlen(buf), buf_size - strlen(buf), enc->channels, enc->channel_layout);
1032         if (enc->sample_fmt != AV_SAMPLE_FMT_NONE) {
1033             snprintf(buf + strlen(buf), buf_size - strlen(buf),
1034                      ", %s", av_get_sample_fmt_name(enc->sample_fmt));
1035         }
1036         break;
1037     case AVMEDIA_TYPE_DATA:
1038         snprintf(buf, buf_size, "Data: %s", codec_name);
1039         break;
1040     case AVMEDIA_TYPE_SUBTITLE:
1041         snprintf(buf, buf_size, "Subtitle: %s", codec_name);
1042         break;
1043     case AVMEDIA_TYPE_ATTACHMENT:
1044         snprintf(buf, buf_size, "Attachment: %s", codec_name);
1045         break;
1046     default:
1047         snprintf(buf, buf_size, "Invalid Codec type %d", enc->codec_type);
1048         return;
1049     }
1050     if (encode) {
1051         if (enc->flags & AV_CODEC_FLAG_PASS1)
1052             snprintf(buf + strlen(buf), buf_size - strlen(buf),
1053                      ", pass 1");
1054         if (enc->flags & AV_CODEC_FLAG_PASS2)
1055             snprintf(buf + strlen(buf), buf_size - strlen(buf),
1056                      ", pass 2");
1057     }
1058     bitrate = get_bit_rate(enc);
1059     if (bitrate != 0) {
1060         snprintf(buf + strlen(buf), buf_size - strlen(buf),
1061                  ", %d kb/s", bitrate / 1000);
1062     }
1063 }
1064
1065 const char *av_get_profile_name(const AVCodec *codec, int profile)
1066 {
1067     const AVProfile *p;
1068     if (profile == FF_PROFILE_UNKNOWN || !codec->profiles)
1069         return NULL;
1070
1071     for (p = codec->profiles; p->profile != FF_PROFILE_UNKNOWN; p++)
1072         if (p->profile == profile)
1073             return p->name;
1074
1075     return NULL;
1076 }
1077
1078 const char *avcodec_profile_name(enum AVCodecID codec_id, int profile)
1079 {
1080     const AVCodecDescriptor *desc = avcodec_descriptor_get(codec_id);
1081     const AVProfile *p;
1082
1083     if (profile == FF_PROFILE_UNKNOWN || !desc || !desc->profiles)
1084         return NULL;
1085
1086     for (p = desc->profiles; p->profile != FF_PROFILE_UNKNOWN; p++)
1087         if (p->profile == profile)
1088             return p->name;
1089
1090     return NULL;
1091 }
1092
1093 unsigned avcodec_version(void)
1094 {
1095     return LIBAVCODEC_VERSION_INT;
1096 }
1097
1098 const char *avcodec_configuration(void)
1099 {
1100     return LIBAV_CONFIGURATION;
1101 }
1102
1103 const char *avcodec_license(void)
1104 {
1105 #define LICENSE_PREFIX "libavcodec license: "
1106     return LICENSE_PREFIX LIBAV_LICENSE + sizeof(LICENSE_PREFIX) - 1;
1107 }
1108
1109 int av_get_exact_bits_per_sample(enum AVCodecID codec_id)
1110 {
1111     switch (codec_id) {
1112     case AV_CODEC_ID_ADPCM_CT:
1113     case AV_CODEC_ID_ADPCM_IMA_APC:
1114     case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
1115     case AV_CODEC_ID_ADPCM_IMA_WS:
1116     case AV_CODEC_ID_ADPCM_G722:
1117     case AV_CODEC_ID_ADPCM_YAMAHA:
1118         return 4;
1119     case AV_CODEC_ID_PCM_ALAW:
1120     case AV_CODEC_ID_PCM_MULAW:
1121     case AV_CODEC_ID_PCM_S8:
1122     case AV_CODEC_ID_PCM_U8:
1123     case AV_CODEC_ID_PCM_ZORK:
1124         return 8;
1125     case AV_CODEC_ID_PCM_S16BE:
1126     case AV_CODEC_ID_PCM_S16BE_PLANAR:
1127     case AV_CODEC_ID_PCM_S16LE:
1128     case AV_CODEC_ID_PCM_S16LE_PLANAR:
1129     case AV_CODEC_ID_PCM_U16BE:
1130     case AV_CODEC_ID_PCM_U16LE:
1131         return 16;
1132     case AV_CODEC_ID_PCM_S24DAUD:
1133     case AV_CODEC_ID_PCM_S24BE:
1134     case AV_CODEC_ID_PCM_S24LE:
1135     case AV_CODEC_ID_PCM_S24LE_PLANAR:
1136     case AV_CODEC_ID_PCM_U24BE:
1137     case AV_CODEC_ID_PCM_U24LE:
1138         return 24;
1139     case AV_CODEC_ID_PCM_S32BE:
1140     case AV_CODEC_ID_PCM_S32LE:
1141     case AV_CODEC_ID_PCM_S32LE_PLANAR:
1142     case AV_CODEC_ID_PCM_U32BE:
1143     case AV_CODEC_ID_PCM_U32LE:
1144     case AV_CODEC_ID_PCM_F32BE:
1145     case AV_CODEC_ID_PCM_F32LE:
1146         return 32;
1147     case AV_CODEC_ID_PCM_F64BE:
1148     case AV_CODEC_ID_PCM_F64LE:
1149         return 64;
1150     default:
1151         return 0;
1152     }
1153 }
1154
1155 int av_get_bits_per_sample(enum AVCodecID codec_id)
1156 {
1157     switch (codec_id) {
1158     case AV_CODEC_ID_ADPCM_SBPRO_2:
1159         return 2;
1160     case AV_CODEC_ID_ADPCM_SBPRO_3:
1161         return 3;
1162     case AV_CODEC_ID_ADPCM_SBPRO_4:
1163     case AV_CODEC_ID_ADPCM_IMA_WAV:
1164     case AV_CODEC_ID_ADPCM_IMA_QT:
1165     case AV_CODEC_ID_ADPCM_SWF:
1166     case AV_CODEC_ID_ADPCM_MS:
1167         return 4;
1168     default:
1169         return av_get_exact_bits_per_sample(codec_id);
1170     }
1171 }
1172
1173 static int get_audio_frame_duration(enum AVCodecID id, int sr, int ch, int ba,
1174                                     uint32_t tag, int bits_per_coded_sample, int frame_bytes)
1175 {
1176     int bps = av_get_exact_bits_per_sample(id);
1177
1178     /* codecs with an exact constant bits per sample */
1179     if (bps > 0 && ch > 0 && frame_bytes > 0)
1180         return (frame_bytes * 8) / (bps * ch);
1181     bps = bits_per_coded_sample;
1182
1183     /* codecs with a fixed packet duration */
1184     switch (id) {
1185     case AV_CODEC_ID_ADPCM_ADX:    return   32;
1186     case AV_CODEC_ID_ADPCM_IMA_QT: return   64;
1187     case AV_CODEC_ID_ADPCM_EA_XAS: return  128;
1188     case AV_CODEC_ID_AMR_NB:
1189     case AV_CODEC_ID_GSM:
1190     case AV_CODEC_ID_QCELP:
1191     case AV_CODEC_ID_RA_144:
1192     case AV_CODEC_ID_RA_288:       return  160;
1193     case AV_CODEC_ID_IMC:          return  256;
1194     case AV_CODEC_ID_AMR_WB:
1195     case AV_CODEC_ID_GSM_MS:       return  320;
1196     case AV_CODEC_ID_MP1:          return  384;
1197     case AV_CODEC_ID_ATRAC1:       return  512;
1198     case AV_CODEC_ID_ATRAC3:       return 1024;
1199     case AV_CODEC_ID_MP2:
1200     case AV_CODEC_ID_MUSEPACK7:    return 1152;
1201     case AV_CODEC_ID_AC3:          return 1536;
1202     }
1203
1204     if (sr > 0) {
1205         /* calc from sample rate */
1206         if (id == AV_CODEC_ID_TTA)
1207             return 256 * sr / 245;
1208
1209         if (ch > 0) {
1210             /* calc from sample rate and channels */
1211             if (id == AV_CODEC_ID_BINKAUDIO_DCT)
1212                 return (480 << (sr / 22050)) / ch;
1213         }
1214
1215         if (id == AV_CODEC_ID_MP3)
1216             return sr <= 24000 ? 576 : 1152;
1217     }
1218
1219     if (ba > 0) {
1220         /* calc from block_align */
1221         if (id == AV_CODEC_ID_SIPR) {
1222             switch (ba) {
1223             case 20: return 160;
1224             case 19: return 144;
1225             case 29: return 288;
1226             case 37: return 480;
1227             }
1228         } else if (id == AV_CODEC_ID_ILBC) {
1229             switch (ba) {
1230             case 38: return 160;
1231             case 50: return 240;
1232             }
1233         }
1234     }
1235
1236     if (frame_bytes > 0) {
1237         /* calc from frame_bytes only */
1238         if (id == AV_CODEC_ID_TRUESPEECH)
1239             return 240 * (frame_bytes / 32);
1240         if (id == AV_CODEC_ID_NELLYMOSER)
1241             return 256 * (frame_bytes / 64);
1242
1243         if (bps > 0) {
1244             /* calc from frame_bytes and bits_per_coded_sample */
1245             if (id == AV_CODEC_ID_ADPCM_G726)
1246                 return frame_bytes * 8 / bps;
1247         }
1248
1249         if (ch > 0) {
1250             /* calc from frame_bytes and channels */
1251             switch (id) {
1252             case AV_CODEC_ID_ADPCM_4XM:
1253             case AV_CODEC_ID_ADPCM_IMA_ISS:
1254                 return (frame_bytes - 4 * ch) * 2 / ch;
1255             case AV_CODEC_ID_ADPCM_IMA_SMJPEG:
1256                 return (frame_bytes - 4) * 2 / ch;
1257             case AV_CODEC_ID_ADPCM_IMA_AMV:
1258                 return (frame_bytes - 8) * 2 / ch;
1259             case AV_CODEC_ID_ADPCM_XA:
1260                 return (frame_bytes / 128) * 224 / ch;
1261             case AV_CODEC_ID_INTERPLAY_DPCM:
1262                 return (frame_bytes - 6 - ch) / ch;
1263             case AV_CODEC_ID_ROQ_DPCM:
1264                 return (frame_bytes - 8) / ch;
1265             case AV_CODEC_ID_XAN_DPCM:
1266                 return (frame_bytes - 2 * ch) / ch;
1267             case AV_CODEC_ID_MACE3:
1268                 return 3 * frame_bytes / ch;
1269             case AV_CODEC_ID_MACE6:
1270                 return 6 * frame_bytes / ch;
1271             case AV_CODEC_ID_PCM_LXF:
1272                 return 2 * (frame_bytes / (5 * ch));
1273             }
1274
1275             if (tag) {
1276                 /* calc from frame_bytes, channels, and codec_tag */
1277                 if (id == AV_CODEC_ID_SOL_DPCM) {
1278                     if (tag == 3)
1279                         return frame_bytes / ch;
1280                     else
1281                         return frame_bytes * 2 / ch;
1282                 }
1283             }
1284
1285             if (ba > 0) {
1286                 /* calc from frame_bytes, channels, and block_align */
1287                 int blocks = frame_bytes / ba;
1288                 switch (id) {
1289                 case AV_CODEC_ID_ADPCM_IMA_WAV:
1290                     return blocks * (1 + (ba - 4 * ch) / (4 * ch) * 8);
1291                 case AV_CODEC_ID_ADPCM_IMA_DK3:
1292                     return blocks * (((ba - 16) * 2 / 3 * 4) / ch);
1293                 case AV_CODEC_ID_ADPCM_IMA_DK4:
1294                     return blocks * (1 + (ba - 4 * ch) * 2 / ch);
1295                 case AV_CODEC_ID_ADPCM_MS:
1296                     return blocks * (2 + (ba - 7 * ch) * 2 / ch);
1297                 }
1298             }
1299
1300             if (bps > 0) {
1301                 /* calc from frame_bytes, channels, and bits_per_coded_sample */
1302                 switch (id) {
1303                 case AV_CODEC_ID_PCM_DVD:
1304                     return 2 * (frame_bytes / ((bps * 2 / 8) * ch));
1305                 case AV_CODEC_ID_PCM_BLURAY:
1306                     return frame_bytes / ((FFALIGN(ch, 2) * bps) / 8);
1307                 case AV_CODEC_ID_S302M:
1308                     return 2 * (frame_bytes / ((bps + 4) / 4)) / ch;
1309                 }
1310             }
1311         }
1312     }
1313
1314     return 0;
1315 }
1316
1317 int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
1318 {
1319     return get_audio_frame_duration(avctx->codec_id, avctx->sample_rate,
1320                                     avctx->channels, avctx->block_align,
1321                                     avctx->codec_tag, avctx->bits_per_coded_sample,
1322                                     frame_bytes);
1323 }
1324
1325 int av_get_audio_frame_duration2(AVCodecParameters *par, int frame_bytes)
1326 {
1327     return get_audio_frame_duration(par->codec_id, par->sample_rate,
1328                                     par->channels, par->block_align,
1329                                     par->codec_tag, par->bits_per_coded_sample,
1330                                     frame_bytes);
1331 }
1332
1333 #if !HAVE_THREADS
1334 int ff_thread_init(AVCodecContext *s)
1335 {
1336     return -1;
1337 }
1338
1339 #endif
1340
1341 unsigned int av_xiphlacing(unsigned char *s, unsigned int v)
1342 {
1343     unsigned int n = 0;
1344
1345     while (v >= 0xff) {
1346         *s++ = 0xff;
1347         v -= 0xff;
1348         n++;
1349     }
1350     *s = v;
1351     n++;
1352     return n;
1353 }
1354
1355 int ff_match_2uint16(const uint16_t(*tab)[2], int size, int a, int b)
1356 {
1357     int i;
1358     for (i = 0; i < size && !(tab[i][0] == a && tab[i][1] == b); i++) ;
1359     return i;
1360 }
1361
1362 #if FF_API_MISSING_SAMPLE
1363 FF_DISABLE_DEPRECATION_WARNINGS
1364 void av_log_missing_feature(void *avc, const char *feature, int want_sample)
1365 {
1366     av_log(avc, AV_LOG_WARNING, "%s is not implemented. Update your Libav "
1367             "version to the newest one from Git. If the problem still "
1368             "occurs, it means that your file has a feature which has not "
1369             "been implemented.\n", feature);
1370     if(want_sample)
1371         av_log_ask_for_sample(avc, NULL);
1372 }
1373
1374 void av_log_ask_for_sample(void *avc, const char *msg, ...)
1375 {
1376     va_list argument_list;
1377
1378     va_start(argument_list, msg);
1379
1380     if (msg)
1381         av_vlog(avc, AV_LOG_WARNING, msg, argument_list);
1382     av_log(avc, AV_LOG_WARNING, "If you want to help, upload a sample "
1383             "of this file to ftp://upload.libav.org/incoming/ "
1384             "and contact the libav-devel mailing list.\n");
1385
1386     va_end(argument_list);
1387 }
1388 FF_ENABLE_DEPRECATION_WARNINGS
1389 #endif /* FF_API_MISSING_SAMPLE */
1390
1391 static AVHWAccel *first_hwaccel = NULL;
1392
1393 void av_register_hwaccel(AVHWAccel *hwaccel)
1394 {
1395     AVHWAccel **p = &first_hwaccel;
1396     while (*p)
1397         p = &(*p)->next;
1398     *p = hwaccel;
1399     hwaccel->next = NULL;
1400 }
1401
1402 AVHWAccel *av_hwaccel_next(const AVHWAccel *hwaccel)
1403 {
1404     return hwaccel ? hwaccel->next : first_hwaccel;
1405 }
1406
1407 int av_lockmgr_register(int (*cb)(void **mutex, enum AVLockOp op))
1408 {
1409     if (lockmgr_cb) {
1410         // There is no good way to rollback a failure to destroy the
1411         // mutex, so we ignore failures.
1412         lockmgr_cb(&codec_mutex,    AV_LOCK_DESTROY);
1413         lockmgr_cb(&avformat_mutex, AV_LOCK_DESTROY);
1414         lockmgr_cb     = NULL;
1415         codec_mutex    = NULL;
1416         avformat_mutex = NULL;
1417     }
1418
1419     if (cb) {
1420         void *new_codec_mutex    = NULL;
1421         void *new_avformat_mutex = NULL;
1422         int err;
1423         if (err = cb(&new_codec_mutex, AV_LOCK_CREATE)) {
1424             return err > 0 ? AVERROR_UNKNOWN : err;
1425         }
1426         if (err = cb(&new_avformat_mutex, AV_LOCK_CREATE)) {
1427             // Ignore failures to destroy the newly created mutex.
1428             cb(&new_codec_mutex, AV_LOCK_DESTROY);
1429             return err > 0 ? AVERROR_UNKNOWN : err;
1430         }
1431         lockmgr_cb     = cb;
1432         codec_mutex    = new_codec_mutex;
1433         avformat_mutex = new_avformat_mutex;
1434     }
1435
1436     return 0;
1437 }
1438
1439 int avpriv_lock_avformat(void)
1440 {
1441     if (lockmgr_cb) {
1442         if ((*lockmgr_cb)(&avformat_mutex, AV_LOCK_OBTAIN))
1443             return -1;
1444     }
1445     return 0;
1446 }
1447
1448 int avpriv_unlock_avformat(void)
1449 {
1450     if (lockmgr_cb) {
1451         if ((*lockmgr_cb)(&avformat_mutex, AV_LOCK_RELEASE))
1452             return -1;
1453     }
1454     return 0;
1455 }
1456
1457 unsigned int avpriv_toupper4(unsigned int x)
1458 {
1459     return av_toupper(x & 0xFF) +
1460           (av_toupper((x >>  8) & 0xFF) << 8)  +
1461           (av_toupper((x >> 16) & 0xFF) << 16) +
1462           (av_toupper((x >> 24) & 0xFF) << 24);
1463 }
1464
1465 int ff_thread_ref_frame(ThreadFrame *dst, ThreadFrame *src)
1466 {
1467     int ret;
1468
1469     dst->owner = src->owner;
1470
1471     ret = av_frame_ref(dst->f, src->f);
1472     if (ret < 0)
1473         return ret;
1474
1475     if (src->progress &&
1476         !(dst->progress = av_buffer_ref(src->progress))) {
1477         ff_thread_release_buffer(dst->owner, dst);
1478         return AVERROR(ENOMEM);
1479     }
1480
1481     return 0;
1482 }
1483
1484 #if !HAVE_THREADS
1485
1486 int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
1487 {
1488     f->owner = avctx;
1489     return ff_get_buffer(avctx, f->f, flags);
1490 }
1491
1492 void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
1493 {
1494     if (f->f)
1495         av_frame_unref(f->f);
1496 }
1497
1498 void ff_thread_finish_setup(AVCodecContext *avctx)
1499 {
1500 }
1501
1502 void ff_thread_report_progress(ThreadFrame *f, int progress, int field)
1503 {
1504 }
1505
1506 void ff_thread_await_progress(ThreadFrame *f, int progress, int field)
1507 {
1508 }
1509
1510 #endif
1511
1512 int avcodec_is_open(AVCodecContext *s)
1513 {
1514     return !!s->internal;
1515 }
1516
1517 const uint8_t *avpriv_find_start_code(const uint8_t *restrict p,
1518                                       const uint8_t *end,
1519                                       uint32_t * restrict state)
1520 {
1521     int i;
1522
1523     assert(p <= end);
1524     if (p >= end)
1525         return end;
1526
1527     for (i = 0; i < 3; i++) {
1528         uint32_t tmp = *state << 8;
1529         *state = tmp + *(p++);
1530         if (tmp == 0x100 || p == end)
1531             return p;
1532     }
1533
1534     while (p < end) {
1535         if      (p[-1] > 1      ) p += 3;
1536         else if (p[-2]          ) p += 2;
1537         else if (p[-3]|(p[-1]-1)) p++;
1538         else {
1539             p++;
1540             break;
1541         }
1542     }
1543
1544     p = FFMIN(p, end) - 4;
1545     *state = AV_RB32(p);
1546
1547     return p + 4;
1548 }
1549
1550 AVCPBProperties *av_cpb_properties_alloc(size_t *size)
1551 {
1552     AVCPBProperties *props = av_mallocz(sizeof(AVCPBProperties));
1553     if (!props)
1554         return NULL;
1555
1556     if (size)
1557         *size = sizeof(*props);
1558
1559     props->vbv_delay = UINT64_MAX;
1560
1561     return props;
1562 }
1563
1564 AVCPBProperties *ff_add_cpb_side_data(AVCodecContext *avctx)
1565 {
1566     AVPacketSideData *tmp;
1567     AVCPBProperties  *props;
1568     size_t size;
1569
1570     props = av_cpb_properties_alloc(&size);
1571     if (!props)
1572         return NULL;
1573
1574     tmp = av_realloc_array(avctx->coded_side_data, avctx->nb_coded_side_data + 1, sizeof(*tmp));
1575     if (!tmp) {
1576         av_freep(&props);
1577         return NULL;
1578     }
1579
1580     avctx->coded_side_data = tmp;
1581     avctx->nb_coded_side_data++;
1582
1583     avctx->coded_side_data[avctx->nb_coded_side_data - 1].type = AV_PKT_DATA_CPB_PROPERTIES;
1584     avctx->coded_side_data[avctx->nb_coded_side_data - 1].data = (uint8_t*)props;
1585     avctx->coded_side_data[avctx->nb_coded_side_data - 1].size = size;
1586
1587     return props;
1588 }
1589
1590 static void codec_parameters_reset(AVCodecParameters *par)
1591 {
1592     av_freep(&par->extradata);
1593
1594     memset(par, 0, sizeof(*par));
1595
1596     par->codec_type          = AVMEDIA_TYPE_UNKNOWN;
1597     par->codec_id            = AV_CODEC_ID_NONE;
1598     par->format              = -1;
1599     par->field_order         = AV_FIELD_UNKNOWN;
1600     par->color_range         = AVCOL_RANGE_UNSPECIFIED;
1601     par->color_primaries     = AVCOL_PRI_UNSPECIFIED;
1602     par->color_trc           = AVCOL_TRC_UNSPECIFIED;
1603     par->color_space         = AVCOL_SPC_UNSPECIFIED;
1604     par->chroma_location     = AVCHROMA_LOC_UNSPECIFIED;
1605     par->sample_aspect_ratio = (AVRational){ 0, 1 };
1606 }
1607
1608 AVCodecParameters *avcodec_parameters_alloc(void)
1609 {
1610     AVCodecParameters *par = av_mallocz(sizeof(*par));
1611
1612     if (!par)
1613         return NULL;
1614     codec_parameters_reset(par);
1615     return par;
1616 }
1617
1618 void avcodec_parameters_free(AVCodecParameters **ppar)
1619 {
1620     AVCodecParameters *par = *ppar;
1621
1622     if (!par)
1623         return;
1624     codec_parameters_reset(par);
1625
1626     av_freep(ppar);
1627 }
1628
1629 int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
1630 {
1631     codec_parameters_reset(dst);
1632     memcpy(dst, src, sizeof(*dst));
1633
1634     dst->extradata      = NULL;
1635     dst->extradata_size = 0;
1636     if (src->extradata) {
1637         dst->extradata = av_mallocz(src->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
1638         if (!dst->extradata)
1639             return AVERROR(ENOMEM);
1640         memcpy(dst->extradata, src->extradata, src->extradata_size);
1641         dst->extradata_size = src->extradata_size;
1642     }
1643
1644     return 0;
1645 }
1646
1647 int avcodec_parameters_from_context(AVCodecParameters *par,
1648                                     const AVCodecContext *codec)
1649 {
1650     codec_parameters_reset(par);
1651
1652     par->codec_type = codec->codec_type;
1653     par->codec_id   = codec->codec_id;
1654     par->codec_tag  = codec->codec_tag;
1655
1656     par->bit_rate              = codec->bit_rate;
1657     par->bits_per_coded_sample = codec->bits_per_coded_sample;
1658     par->profile               = codec->profile;
1659     par->level                 = codec->level;
1660
1661     switch (par->codec_type) {
1662     case AVMEDIA_TYPE_VIDEO:
1663         par->format              = codec->pix_fmt;
1664         par->width               = codec->width;
1665         par->height              = codec->height;
1666         par->field_order         = codec->field_order;
1667         par->color_range         = codec->color_range;
1668         par->color_primaries     = codec->color_primaries;
1669         par->color_trc           = codec->color_trc;
1670         par->color_space         = codec->colorspace;
1671         par->chroma_location     = codec->chroma_sample_location;
1672         par->sample_aspect_ratio = codec->sample_aspect_ratio;
1673         break;
1674     case AVMEDIA_TYPE_AUDIO:
1675         par->format          = codec->sample_fmt;
1676         par->channel_layout  = codec->channel_layout;
1677         par->channels        = codec->channels;
1678         par->sample_rate     = codec->sample_rate;
1679         par->block_align     = codec->block_align;
1680         par->initial_padding = codec->initial_padding;
1681         break;
1682     }
1683
1684     if (codec->extradata) {
1685         par->extradata = av_mallocz(codec->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
1686         if (!par->extradata)
1687             return AVERROR(ENOMEM);
1688         memcpy(par->extradata, codec->extradata, codec->extradata_size);
1689         par->extradata_size = codec->extradata_size;
1690     }
1691
1692     return 0;
1693 }
1694
1695 int avcodec_parameters_to_context(AVCodecContext *codec,
1696                                   const AVCodecParameters *par)
1697 {
1698     codec->codec_type = par->codec_type;
1699     codec->codec_id   = par->codec_id;
1700     codec->codec_tag  = par->codec_tag;
1701
1702     codec->bit_rate              = par->bit_rate;
1703     codec->bits_per_coded_sample = par->bits_per_coded_sample;
1704     codec->profile               = par->profile;
1705     codec->level                 = par->level;
1706
1707     switch (par->codec_type) {
1708     case AVMEDIA_TYPE_VIDEO:
1709         codec->pix_fmt                = par->format;
1710         codec->width                  = par->width;
1711         codec->height                 = par->height;
1712         codec->field_order            = par->field_order;
1713         codec->color_range            = par->color_range;
1714         codec->color_primaries        = par->color_primaries;
1715         codec->color_trc              = par->color_trc;
1716         codec->colorspace             = par->color_space;
1717         codec->chroma_sample_location = par->chroma_location;
1718         codec->sample_aspect_ratio    = par->sample_aspect_ratio;
1719         break;
1720     case AVMEDIA_TYPE_AUDIO:
1721         codec->sample_fmt      = par->format;
1722         codec->channel_layout  = par->channel_layout;
1723         codec->channels        = par->channels;
1724         codec->sample_rate     = par->sample_rate;
1725         codec->block_align     = par->block_align;
1726         codec->initial_padding = par->initial_padding;
1727         break;
1728     }
1729
1730     if (par->extradata) {
1731         av_freep(&codec->extradata);
1732         codec->extradata = av_mallocz(par->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
1733         if (!codec->extradata)
1734             return AVERROR(ENOMEM);
1735         memcpy(codec->extradata, par->extradata, par->extradata_size);
1736         codec->extradata_size = par->extradata_size;
1737     }
1738
1739     return 0;
1740 }