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