6226b2841f9af92fbf8e8843263c1857e1723f87
[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 "libavutil/avassert.h"
29 #include "libavutil/avstring.h"
30 #include "libavutil/channel_layout.h"
31 #include "libavutil/crc.h"
32 #include "libavutil/mathematics.h"
33 #include "libavutil/pixdesc.h"
34 #include "libavutil/imgutils.h"
35 #include "libavutil/samplefmt.h"
36 #include "libavutil/dict.h"
37 #include "avcodec.h"
38 #include "dsputil.h"
39 #include "libavutil/opt.h"
40 #include "thread.h"
41 #include "internal.h"
42 #include "bytestream.h"
43 #include <stdlib.h>
44 #include <stdarg.h>
45 #include <limits.h>
46 #include <float.h>
47
48 static int volatile entangled_thread_counter = 0;
49 static int (*ff_lockmgr_cb)(void **mutex, enum AVLockOp op);
50 static void *codec_mutex;
51 static void *avformat_mutex;
52
53 void *av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
54 {
55     if (min_size < *size)
56         return ptr;
57
58     min_size = FFMAX(17 * min_size / 16 + 32, min_size);
59
60     ptr = av_realloc(ptr, min_size);
61     /* we could set this to the unmodified min_size but this is safer
62      * if the user lost the ptr and uses NULL now
63      */
64     if (!ptr)
65         min_size = 0;
66
67     *size = min_size;
68
69     return ptr;
70 }
71
72 void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
73 {
74     void **p = ptr;
75     if (min_size < *size)
76         return;
77     min_size = FFMAX(17 * min_size / 16 + 32, min_size);
78     av_free(*p);
79     *p = av_malloc(min_size);
80     if (!*p)
81         min_size = 0;
82     *size = min_size;
83 }
84
85 void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
86 {
87     void **p = ptr;
88     if (min_size > SIZE_MAX - FF_INPUT_BUFFER_PADDING_SIZE) {
89         av_freep(p);
90         *size = 0;
91         return;
92     }
93     av_fast_malloc(p, size, min_size + FF_INPUT_BUFFER_PADDING_SIZE);
94     if (*size)
95         memset((uint8_t *)*p + min_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
96 }
97
98 /* encoder management */
99 static AVCodec *first_avcodec = NULL;
100
101 AVCodec *av_codec_next(const AVCodec *c)
102 {
103     if (c)
104         return c->next;
105     else
106         return first_avcodec;
107 }
108
109 static void avcodec_init(void)
110 {
111     static int initialized = 0;
112
113     if (initialized != 0)
114         return;
115     initialized = 1;
116
117     ff_dsputil_static_init();
118 }
119
120 int av_codec_is_encoder(const AVCodec *codec)
121 {
122     return codec && (codec->encode_sub || codec->encode2);
123 }
124
125 int av_codec_is_decoder(const AVCodec *codec)
126 {
127     return codec && codec->decode;
128 }
129
130 void avcodec_register(AVCodec *codec)
131 {
132     AVCodec **p;
133     avcodec_init();
134     p = &first_avcodec;
135     while (*p != NULL)
136         p = &(*p)->next;
137     *p          = codec;
138     codec->next = NULL;
139
140     if (codec->init_static_data)
141         codec->init_static_data(codec);
142 }
143
144 unsigned avcodec_get_edge_width(void)
145 {
146     return EDGE_WIDTH;
147 }
148
149 void avcodec_set_dimensions(AVCodecContext *s, int width, int height)
150 {
151     s->coded_width  = width;
152     s->coded_height = height;
153     s->width        = width;
154     s->height       = height;
155 }
156
157 #define INTERNAL_BUFFER_SIZE (32 + 1)
158
159 void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height,
160                                int linesize_align[AV_NUM_DATA_POINTERS])
161 {
162     int i;
163     int w_align = 1;
164     int h_align = 1;
165
166     switch (s->pix_fmt) {
167     case AV_PIX_FMT_YUV420P:
168     case AV_PIX_FMT_YUYV422:
169     case AV_PIX_FMT_UYVY422:
170     case AV_PIX_FMT_YUV422P:
171     case AV_PIX_FMT_YUV440P:
172     case AV_PIX_FMT_YUV444P:
173     case AV_PIX_FMT_GBRP:
174     case AV_PIX_FMT_GRAY8:
175     case AV_PIX_FMT_GRAY16BE:
176     case AV_PIX_FMT_GRAY16LE:
177     case AV_PIX_FMT_YUVJ420P:
178     case AV_PIX_FMT_YUVJ422P:
179     case AV_PIX_FMT_YUVJ440P:
180     case AV_PIX_FMT_YUVJ444P:
181     case AV_PIX_FMT_YUVA420P:
182     case AV_PIX_FMT_YUVA422P:
183     case AV_PIX_FMT_YUVA444P:
184     case AV_PIX_FMT_YUV420P9LE:
185     case AV_PIX_FMT_YUV420P9BE:
186     case AV_PIX_FMT_YUV420P10LE:
187     case AV_PIX_FMT_YUV420P10BE:
188     case AV_PIX_FMT_YUV422P9LE:
189     case AV_PIX_FMT_YUV422P9BE:
190     case AV_PIX_FMT_YUV422P10LE:
191     case AV_PIX_FMT_YUV422P10BE:
192     case AV_PIX_FMT_YUV444P9LE:
193     case AV_PIX_FMT_YUV444P9BE:
194     case AV_PIX_FMT_YUV444P10LE:
195     case AV_PIX_FMT_YUV444P10BE:
196     case AV_PIX_FMT_GBRP9LE:
197     case AV_PIX_FMT_GBRP9BE:
198     case AV_PIX_FMT_GBRP10LE:
199     case AV_PIX_FMT_GBRP10BE:
200         w_align = 16; //FIXME assume 16 pixel per macroblock
201         h_align = 16 * 2; // interlaced needs 2 macroblocks height
202         break;
203     case AV_PIX_FMT_YUV411P:
204     case AV_PIX_FMT_UYYVYY411:
205         w_align = 32;
206         h_align = 8;
207         break;
208     case AV_PIX_FMT_YUV410P:
209         if (s->codec_id == AV_CODEC_ID_SVQ1) {
210             w_align = 64;
211             h_align = 64;
212         }
213     case AV_PIX_FMT_RGB555:
214         if (s->codec_id == AV_CODEC_ID_RPZA) {
215             w_align = 4;
216             h_align = 4;
217         }
218     case AV_PIX_FMT_PAL8:
219     case AV_PIX_FMT_BGR8:
220     case AV_PIX_FMT_RGB8:
221         if (s->codec_id == AV_CODEC_ID_SMC) {
222             w_align = 4;
223             h_align = 4;
224         }
225         break;
226     case AV_PIX_FMT_BGR24:
227         if ((s->codec_id == AV_CODEC_ID_MSZH) ||
228             (s->codec_id == AV_CODEC_ID_ZLIB)) {
229             w_align = 4;
230             h_align = 4;
231         }
232         break;
233     default:
234         w_align = 1;
235         h_align = 1;
236         break;
237     }
238
239     *width  = FFALIGN(*width, w_align);
240     *height = FFALIGN(*height, h_align);
241     if (s->codec_id == AV_CODEC_ID_H264)
242         // some of the optimized chroma MC reads one line too much
243         *height += 2;
244
245     for (i = 0; i < 4; i++)
246         linesize_align[i] = STRIDE_ALIGN;
247 }
248
249 void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height)
250 {
251     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->pix_fmt);
252     int chroma_shift = desc->log2_chroma_w;
253     int linesize_align[AV_NUM_DATA_POINTERS];
254     int align;
255
256     avcodec_align_dimensions2(s, width, height, linesize_align);
257     align               = FFMAX(linesize_align[0], linesize_align[3]);
258     linesize_align[1] <<= chroma_shift;
259     linesize_align[2] <<= chroma_shift;
260     align               = FFMAX3(align, linesize_align[1], linesize_align[2]);
261     *width              = FFALIGN(*width, align);
262 }
263
264 int avcodec_fill_audio_frame(AVFrame *frame, int nb_channels,
265                              enum AVSampleFormat sample_fmt, const uint8_t *buf,
266                              int buf_size, int align)
267 {
268     int ch, planar, needed_size, ret = 0;
269
270     needed_size = av_samples_get_buffer_size(NULL, nb_channels,
271                                              frame->nb_samples, sample_fmt,
272                                              align);
273     if (buf_size < needed_size)
274         return AVERROR(EINVAL);
275
276     planar = av_sample_fmt_is_planar(sample_fmt);
277     if (planar && nb_channels > AV_NUM_DATA_POINTERS) {
278         if (!(frame->extended_data = av_mallocz(nb_channels *
279                                                 sizeof(*frame->extended_data))))
280             return AVERROR(ENOMEM);
281     } else {
282         frame->extended_data = frame->data;
283     }
284
285     if ((ret = av_samples_fill_arrays(frame->extended_data, &frame->linesize[0],
286                                       buf, nb_channels, frame->nb_samples,
287                                       sample_fmt, align)) < 0) {
288         if (frame->extended_data != frame->data)
289             av_free(frame->extended_data);
290         return ret;
291     }
292     if (frame->extended_data != frame->data) {
293         for (ch = 0; ch < AV_NUM_DATA_POINTERS; ch++)
294             frame->data[ch] = frame->extended_data[ch];
295     }
296
297     return ret;
298 }
299
300 static int audio_get_buffer(AVCodecContext *avctx, AVFrame *frame)
301 {
302     AVCodecInternal *avci = avctx->internal;
303     InternalBuffer *buf;
304     int buf_size, ret;
305
306     buf_size = av_samples_get_buffer_size(NULL, avctx->channels,
307                                           frame->nb_samples, avctx->sample_fmt,
308                                           0);
309     if (buf_size < 0)
310         return AVERROR(EINVAL);
311
312     /* allocate InternalBuffer if needed */
313     if (!avci->buffer) {
314         avci->buffer = av_mallocz(sizeof(InternalBuffer));
315         if (!avci->buffer)
316             return AVERROR(ENOMEM);
317     }
318     buf = avci->buffer;
319
320     /* if there is a previously-used internal buffer, check its size and
321      * channel count to see if we can reuse it */
322     if (buf->extended_data) {
323         /* if current buffer is too small, free it */
324         if (buf->extended_data[0] && buf_size > buf->audio_data_size) {
325             av_free(buf->extended_data[0]);
326             if (buf->extended_data != buf->data)
327                 av_free(buf->extended_data);
328             buf->extended_data = NULL;
329             buf->data[0]       = NULL;
330         }
331         /* if number of channels has changed, reset and/or free extended data
332          * pointers but leave data buffer in buf->data[0] for reuse */
333         if (buf->nb_channels != avctx->channels) {
334             if (buf->extended_data != buf->data)
335                 av_free(buf->extended_data);
336             buf->extended_data = NULL;
337         }
338     }
339
340     /* if there is no previous buffer or the previous buffer cannot be used
341      * as-is, allocate a new buffer and/or rearrange the channel pointers */
342     if (!buf->extended_data) {
343         if (!buf->data[0]) {
344             if (!(buf->data[0] = av_mallocz(buf_size)))
345                 return AVERROR(ENOMEM);
346             buf->audio_data_size = buf_size;
347         }
348         if ((ret = avcodec_fill_audio_frame(frame, avctx->channels,
349                                             avctx->sample_fmt, buf->data[0],
350                                             buf->audio_data_size, 0)))
351             return ret;
352
353         if (frame->extended_data == frame->data)
354             buf->extended_data = buf->data;
355         else
356             buf->extended_data = frame->extended_data;
357         memcpy(buf->data, frame->data, sizeof(frame->data));
358         buf->linesize[0] = frame->linesize[0];
359         buf->nb_channels = avctx->channels;
360     } else {
361         /* copy InternalBuffer info to the AVFrame */
362         frame->extended_data = buf->extended_data;
363         frame->linesize[0]   = buf->linesize[0];
364         memcpy(frame->data, buf->data, sizeof(frame->data));
365     }
366
367     frame->type = FF_BUFFER_TYPE_INTERNAL;
368
369     if (avctx->debug & FF_DEBUG_BUFFERS)
370         av_log(avctx, AV_LOG_DEBUG, "default_get_buffer called on frame %p, "
371                                     "internal audio buffer used\n", frame);
372
373     return 0;
374 }
375
376 static int video_get_buffer(AVCodecContext *s, AVFrame *pic)
377 {
378     int i;
379     int w = s->width;
380     int h = s->height;
381     InternalBuffer *buf;
382     AVCodecInternal *avci = s->internal;
383
384     if (pic->data[0] != NULL) {
385         av_log(s, AV_LOG_ERROR, "pic->data[0]!=NULL in avcodec_default_get_buffer\n");
386         return -1;
387     }
388     if (avci->buffer_count >= INTERNAL_BUFFER_SIZE) {
389         av_log(s, AV_LOG_ERROR, "buffer_count overflow (missing release_buffer?)\n");
390         return -1;
391     }
392
393     if (av_image_check_size(w, h, 0, s))
394         return -1;
395
396     if (!avci->buffer) {
397         avci->buffer = av_mallocz((INTERNAL_BUFFER_SIZE + 1) *
398                                   sizeof(InternalBuffer));
399     }
400
401     buf = &avci->buffer[avci->buffer_count];
402
403     if (buf->base[0] && (buf->width != w || buf->height != h || buf->pix_fmt != s->pix_fmt)) {
404         for (i = 0; i < AV_NUM_DATA_POINTERS; i++) {
405             av_freep(&buf->base[i]);
406             buf->data[i] = NULL;
407         }
408     }
409
410     if (!buf->base[0]) {
411         int h_chroma_shift, v_chroma_shift;
412         int size[4] = { 0 };
413         int tmpsize;
414         int unaligned;
415         AVPicture picture;
416         int stride_align[AV_NUM_DATA_POINTERS];
417         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->pix_fmt);
418         const int pixel_size = desc->comp[0].step_minus1 + 1;
419
420         av_pix_fmt_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift,
421                                          &v_chroma_shift);
422
423         avcodec_align_dimensions2(s, &w, &h, stride_align);
424
425         if (!(s->flags & CODEC_FLAG_EMU_EDGE)) {
426             w += EDGE_WIDTH * 2;
427             h += EDGE_WIDTH * 2;
428         }
429
430         do {
431             // NOTE: do not align linesizes individually, this breaks e.g. assumptions
432             // that linesize[0] == 2*linesize[1] in the MPEG-encoder for 4:2:2
433             av_image_fill_linesizes(picture.linesize, s->pix_fmt, w);
434             // increase alignment of w for next try (rhs gives the lowest bit set in w)
435             w += w & ~(w - 1);
436
437             unaligned = 0;
438             for (i = 0; i < 4; i++)
439                 unaligned |= picture.linesize[i] % stride_align[i];
440         } while (unaligned);
441
442         tmpsize = av_image_fill_pointers(picture.data, s->pix_fmt, h, NULL, picture.linesize);
443         if (tmpsize < 0)
444             return -1;
445
446         for (i = 0; i < 3 && picture.data[i + 1]; i++)
447             size[i] = picture.data[i + 1] - picture.data[i];
448         size[i] = tmpsize - (picture.data[i] - picture.data[0]);
449
450         memset(buf->base, 0, sizeof(buf->base));
451         memset(buf->data, 0, sizeof(buf->data));
452
453         for (i = 0; i < 4 && size[i]; i++) {
454             const int h_shift = i == 0 ? 0 : h_chroma_shift;
455             const int v_shift = i == 0 ? 0 : v_chroma_shift;
456
457             buf->linesize[i] = picture.linesize[i];
458
459             buf->base[i] = av_malloc(size[i] + 16); //FIXME 16
460             if (buf->base[i] == NULL)
461                 return -1;
462             memset(buf->base[i], 128, size[i]);
463
464             // no edge if EDGE EMU or not planar YUV
465             if ((s->flags & CODEC_FLAG_EMU_EDGE) || !size[2])
466                 buf->data[i] = buf->base[i];
467             else
468                 buf->data[i] = buf->base[i] + FFALIGN((buf->linesize[i] * EDGE_WIDTH >> v_shift) + (pixel_size * EDGE_WIDTH >> h_shift), stride_align[i]);
469         }
470         for (; i < AV_NUM_DATA_POINTERS; i++) {
471             buf->base[i]     = buf->data[i] = NULL;
472             buf->linesize[i] = 0;
473         }
474         if (size[1] && !size[2])
475             avpriv_set_systematic_pal2((uint32_t *)buf->data[1], s->pix_fmt);
476         buf->width   = s->width;
477         buf->height  = s->height;
478         buf->pix_fmt = s->pix_fmt;
479     }
480     pic->type = FF_BUFFER_TYPE_INTERNAL;
481
482     for (i = 0; i < AV_NUM_DATA_POINTERS; i++) {
483         pic->base[i]     = buf->base[i];
484         pic->data[i]     = buf->data[i];
485         pic->linesize[i] = buf->linesize[i];
486     }
487     pic->extended_data = pic->data;
488     avci->buffer_count++;
489
490     if (s->debug & FF_DEBUG_BUFFERS)
491         av_log(s, AV_LOG_DEBUG, "default_get_buffer called on pic %p, %d "
492                                 "buffers used\n", pic, avci->buffer_count);
493
494     return 0;
495 }
496
497 int avcodec_default_get_buffer(AVCodecContext *avctx, AVFrame *frame)
498 {
499     switch (avctx->codec_type) {
500     case AVMEDIA_TYPE_VIDEO:
501         return video_get_buffer(avctx, frame);
502     case AVMEDIA_TYPE_AUDIO:
503         return audio_get_buffer(avctx, frame);
504     default:
505         return -1;
506     }
507 }
508
509 int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame)
510 {
511     switch (avctx->codec_type) {
512     case AVMEDIA_TYPE_VIDEO:
513         frame->width               = avctx->width;
514         frame->height              = avctx->height;
515         frame->format              = avctx->pix_fmt;
516         frame->sample_aspect_ratio = avctx->sample_aspect_ratio;
517         break;
518     case AVMEDIA_TYPE_AUDIO:
519         frame->sample_rate    = avctx->sample_rate;
520         frame->format         = avctx->sample_fmt;
521         frame->channel_layout = avctx->channel_layout;
522         break;
523     default: return AVERROR(EINVAL);
524     }
525
526     frame->pkt_pts = avctx->pkt ? avctx->pkt->pts : AV_NOPTS_VALUE;
527     frame->reordered_opaque = avctx->reordered_opaque;
528
529     return avctx->get_buffer(avctx, frame);
530 }
531
532 void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic)
533 {
534     int i;
535     InternalBuffer *buf, *last;
536     AVCodecInternal *avci = s->internal;
537
538     assert(s->codec_type == AVMEDIA_TYPE_VIDEO);
539
540     assert(pic->type == FF_BUFFER_TYPE_INTERNAL);
541     assert(avci->buffer_count);
542
543     if (avci->buffer) {
544         buf = NULL; /* avoids warning */
545         for (i = 0; i < avci->buffer_count; i++) { //just 3-5 checks so is not worth to optimize
546             buf = &avci->buffer[i];
547             if (buf->data[0] == pic->data[0])
548                 break;
549         }
550         assert(i < avci->buffer_count);
551         avci->buffer_count--;
552         last = &avci->buffer[avci->buffer_count];
553
554         if (buf != last)
555             FFSWAP(InternalBuffer, *buf, *last);
556     }
557
558     for (i = 0; i < AV_NUM_DATA_POINTERS; i++)
559         pic->data[i] = NULL;
560 //        pic->base[i]=NULL;
561
562     if (s->debug & FF_DEBUG_BUFFERS)
563         av_log(s, AV_LOG_DEBUG, "default_release_buffer called on pic %p, %d "
564                                 "buffers used\n", pic, avci->buffer_count);
565 }
566
567 int avcodec_default_reget_buffer(AVCodecContext *s, AVFrame *pic)
568 {
569     AVFrame temp_pic;
570     int i;
571
572     assert(s->codec_type == AVMEDIA_TYPE_VIDEO);
573
574     /* If no picture return a new buffer */
575     if (pic->data[0] == NULL) {
576         /* We will copy from buffer, so must be readable */
577         pic->buffer_hints |= FF_BUFFER_HINTS_READABLE;
578         return ff_get_buffer(s, pic);
579     }
580
581     assert(s->pix_fmt == pic->format);
582
583     /* If internal buffer type return the same buffer */
584     if (pic->type == FF_BUFFER_TYPE_INTERNAL) {
585         if (s->pkt)
586             pic->pkt_pts = s->pkt->pts;
587         else
588             pic->pkt_pts = AV_NOPTS_VALUE;
589         pic->reordered_opaque = s->reordered_opaque;
590         return 0;
591     }
592
593     /*
594      * Not internal type and reget_buffer not overridden, emulate cr buffer
595      */
596     temp_pic = *pic;
597     for (i = 0; i < AV_NUM_DATA_POINTERS; i++)
598         pic->data[i] = pic->base[i] = NULL;
599     pic->opaque = NULL;
600     /* Allocate new frame */
601     if (ff_get_buffer(s, pic))
602         return -1;
603     /* Copy image data from old buffer to new buffer */
604     av_picture_copy((AVPicture *)pic, (AVPicture *)&temp_pic, s->pix_fmt, s->width,
605                     s->height);
606     s->release_buffer(s, &temp_pic); // Release old frame
607     return 0;
608 }
609
610 int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2), void *arg, int *ret, int count, int size)
611 {
612     int i;
613
614     for (i = 0; i < count; i++) {
615         int r = func(c, (char *)arg + i * size);
616         if (ret)
617             ret[i] = r;
618     }
619     return 0;
620 }
621
622 int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int jobnr, int threadnr), void *arg, int *ret, int count)
623 {
624     int i;
625
626     for (i = 0; i < count; i++) {
627         int r = func(c, arg, i, 0);
628         if (ret)
629             ret[i] = r;
630     }
631     return 0;
632 }
633
634 static int is_hwaccel_pix_fmt(enum AVPixelFormat pix_fmt)
635 {
636     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
637     return desc->flags & PIX_FMT_HWACCEL;
638 }
639
640 enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum AVPixelFormat *fmt)
641 {
642     while (*fmt != AV_PIX_FMT_NONE && is_hwaccel_pix_fmt(*fmt))
643         ++fmt;
644     return fmt[0];
645 }
646
647 void avcodec_get_frame_defaults(AVFrame *frame)
648 {
649     if (frame->extended_data != frame->data)
650         av_freep(&frame->extended_data);
651
652     memset(frame, 0, sizeof(AVFrame));
653
654     frame->pts                 = AV_NOPTS_VALUE;
655     frame->key_frame           = 1;
656     frame->sample_aspect_ratio = (AVRational) {0, 1 };
657     frame->format              = -1; /* unknown */
658     frame->extended_data       = frame->data;
659 }
660
661 AVFrame *avcodec_alloc_frame(void)
662 {
663     AVFrame *frame = av_mallocz(sizeof(AVFrame));
664
665     if (frame == NULL)
666         return NULL;
667
668     avcodec_get_frame_defaults(frame);
669
670     return frame;
671 }
672
673 void avcodec_free_frame(AVFrame **frame)
674 {
675     AVFrame *f;
676
677     if (!frame || !*frame)
678         return;
679
680     f = *frame;
681
682     if (f->extended_data != f->data)
683         av_freep(&f->extended_data);
684
685     av_freep(frame);
686 }
687
688 int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
689 {
690     int ret = 0;
691     AVDictionary *tmp = NULL;
692
693     if (avcodec_is_open(avctx))
694         return 0;
695
696     if ((!codec && !avctx->codec)) {
697         av_log(avctx, AV_LOG_ERROR, "No codec provided to avcodec_open2().\n");
698         return AVERROR(EINVAL);
699     }
700     if ((codec && avctx->codec && codec != avctx->codec)) {
701         av_log(avctx, AV_LOG_ERROR, "This AVCodecContext was allocated for %s, "
702                                     "but %s passed to avcodec_open2().\n", avctx->codec->name, codec->name);
703         return AVERROR(EINVAL);
704     }
705     if (!codec)
706         codec = avctx->codec;
707
708     if (avctx->extradata_size < 0 || avctx->extradata_size >= FF_MAX_EXTRADATA_SIZE)
709         return AVERROR(EINVAL);
710
711     if (options)
712         av_dict_copy(&tmp, *options, 0);
713
714     /* If there is a user-supplied mutex locking routine, call it. */
715     if (ff_lockmgr_cb) {
716         if ((*ff_lockmgr_cb)(&codec_mutex, AV_LOCK_OBTAIN))
717             return -1;
718     }
719
720     entangled_thread_counter++;
721     if (entangled_thread_counter != 1) {
722         av_log(avctx, AV_LOG_ERROR, "insufficient thread locking around avcodec_open/close()\n");
723         ret = -1;
724         goto end;
725     }
726
727     avctx->internal = av_mallocz(sizeof(AVCodecInternal));
728     if (!avctx->internal) {
729         ret = AVERROR(ENOMEM);
730         goto end;
731     }
732
733     if (codec->priv_data_size > 0) {
734         if (!avctx->priv_data) {
735             avctx->priv_data = av_mallocz(codec->priv_data_size);
736             if (!avctx->priv_data) {
737                 ret = AVERROR(ENOMEM);
738                 goto end;
739             }
740             if (codec->priv_class) {
741                 *(const AVClass **)avctx->priv_data = codec->priv_class;
742                 av_opt_set_defaults(avctx->priv_data);
743             }
744         }
745         if (codec->priv_class && (ret = av_opt_set_dict(avctx->priv_data, &tmp)) < 0)
746             goto free_and_end;
747     } else {
748         avctx->priv_data = NULL;
749     }
750     if ((ret = av_opt_set_dict(avctx, &tmp)) < 0)
751         goto free_and_end;
752
753     if (avctx->coded_width && avctx->coded_height)
754         avcodec_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);
755     else if (avctx->width && avctx->height)
756         avcodec_set_dimensions(avctx, avctx->width, avctx->height);
757
758     if ((avctx->coded_width || avctx->coded_height || avctx->width || avctx->height)
759         && (  av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx) < 0
760            || av_image_check_size(avctx->width,       avctx->height,       0, avctx) < 0)) {
761         av_log(avctx, AV_LOG_WARNING, "ignoring invalid width/height values\n");
762         avcodec_set_dimensions(avctx, 0, 0);
763     }
764
765     /* if the decoder init function was already called previously,
766      * free the already allocated subtitle_header before overwriting it */
767     if (av_codec_is_decoder(codec))
768         av_freep(&avctx->subtitle_header);
769
770     if (avctx->channels > FF_SANE_NB_CHANNELS) {
771         ret = AVERROR(EINVAL);
772         goto free_and_end;
773     }
774
775     avctx->codec = codec;
776     if ((avctx->codec_type == AVMEDIA_TYPE_UNKNOWN || avctx->codec_type == codec->type) &&
777         avctx->codec_id == AV_CODEC_ID_NONE) {
778         avctx->codec_type = codec->type;
779         avctx->codec_id   = codec->id;
780     }
781     if (avctx->codec_id != codec->id || (avctx->codec_type != codec->type
782                                          && avctx->codec_type != AVMEDIA_TYPE_ATTACHMENT)) {
783         av_log(avctx, AV_LOG_ERROR, "codec type or id mismatches\n");
784         ret = AVERROR(EINVAL);
785         goto free_and_end;
786     }
787     avctx->frame_number = 0;
788
789     if (avctx->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
790         avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
791         ret = AVERROR_EXPERIMENTAL;
792         goto free_and_end;
793     }
794
795     if (avctx->codec_type == AVMEDIA_TYPE_AUDIO &&
796         (!avctx->time_base.num || !avctx->time_base.den)) {
797         avctx->time_base.num = 1;
798         avctx->time_base.den = avctx->sample_rate;
799     }
800
801     if (HAVE_THREADS && !avctx->thread_opaque) {
802         ret = ff_thread_init(avctx);
803         if (ret < 0) {
804             goto free_and_end;
805         }
806     }
807     if (!HAVE_THREADS && !(codec->capabilities & CODEC_CAP_AUTO_THREADS))
808         avctx->thread_count = 1;
809
810     if (av_codec_is_encoder(avctx->codec)) {
811         int i;
812         if (avctx->codec->sample_fmts) {
813             for (i = 0; avctx->codec->sample_fmts[i] != AV_SAMPLE_FMT_NONE; i++) {
814                 if (avctx->sample_fmt == avctx->codec->sample_fmts[i])
815                     break;
816                 if (avctx->channels == 1 &&
817                     av_get_planar_sample_fmt(avctx->sample_fmt) ==
818                     av_get_planar_sample_fmt(avctx->codec->sample_fmts[i])) {
819                     avctx->sample_fmt = avctx->codec->sample_fmts[i];
820                     break;
821                 }
822             }
823             if (avctx->codec->sample_fmts[i] == AV_SAMPLE_FMT_NONE) {
824                 av_log(avctx, AV_LOG_ERROR, "Specified sample_fmt is not supported.\n");
825                 ret = AVERROR(EINVAL);
826                 goto free_and_end;
827             }
828         }
829         if (avctx->codec->pix_fmts) {
830             for (i = 0; avctx->codec->pix_fmts[i] != AV_PIX_FMT_NONE; i++)
831                 if (avctx->pix_fmt == avctx->codec->pix_fmts[i])
832                     break;
833             if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_NONE) {
834                 av_log(avctx, AV_LOG_ERROR, "Specified pix_fmt is not supported\n");
835                 ret = AVERROR(EINVAL);
836                 goto free_and_end;
837             }
838         }
839         if (avctx->codec->supported_samplerates) {
840             for (i = 0; avctx->codec->supported_samplerates[i] != 0; i++)
841                 if (avctx->sample_rate == avctx->codec->supported_samplerates[i])
842                     break;
843             if (avctx->codec->supported_samplerates[i] == 0) {
844                 av_log(avctx, AV_LOG_ERROR, "Specified sample_rate is not supported\n");
845                 ret = AVERROR(EINVAL);
846                 goto free_and_end;
847             }
848         }
849         if (avctx->codec->channel_layouts) {
850             if (!avctx->channel_layout) {
851                 av_log(avctx, AV_LOG_WARNING, "channel_layout not specified\n");
852             } else {
853                 for (i = 0; avctx->codec->channel_layouts[i] != 0; i++)
854                     if (avctx->channel_layout == avctx->codec->channel_layouts[i])
855                         break;
856                 if (avctx->codec->channel_layouts[i] == 0) {
857                     av_log(avctx, AV_LOG_ERROR, "Specified channel_layout is not supported\n");
858                     ret = AVERROR(EINVAL);
859                     goto free_and_end;
860                 }
861             }
862         }
863         if (avctx->channel_layout && avctx->channels) {
864             if (av_get_channel_layout_nb_channels(avctx->channel_layout) != avctx->channels) {
865                 av_log(avctx, AV_LOG_ERROR, "channel layout does not match number of channels\n");
866                 ret = AVERROR(EINVAL);
867                 goto free_and_end;
868             }
869         } else if (avctx->channel_layout) {
870             avctx->channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
871         }
872     }
873
874     if (avctx->codec->init && !(avctx->active_thread_type & FF_THREAD_FRAME)) {
875         ret = avctx->codec->init(avctx);
876         if (ret < 0) {
877             goto free_and_end;
878         }
879     }
880
881     if (av_codec_is_decoder(avctx->codec)) {
882         /* validate channel layout from the decoder */
883         if (avctx->channel_layout) {
884             int channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
885             if (!avctx->channels)
886                 avctx->channels = channels;
887             else if (channels != avctx->channels) {
888                 av_log(avctx, AV_LOG_WARNING,
889                        "channel layout does not match number of channels\n");
890                 avctx->channel_layout = 0;
891             }
892         }
893         if (avctx->channels && avctx->channels < 0 ||
894             avctx->channels > FF_SANE_NB_CHANNELS) {
895             ret = AVERROR(EINVAL);
896             goto free_and_end;
897         }
898     }
899 end:
900     entangled_thread_counter--;
901
902     /* Release any user-supplied mutex. */
903     if (ff_lockmgr_cb) {
904         (*ff_lockmgr_cb)(&codec_mutex, AV_LOCK_RELEASE);
905     }
906     if (options) {
907         av_dict_free(options);
908         *options = tmp;
909     }
910
911     return ret;
912 free_and_end:
913     av_dict_free(&tmp);
914     av_freep(&avctx->priv_data);
915     av_freep(&avctx->internal);
916     avctx->codec = NULL;
917     goto end;
918 }
919
920 int ff_alloc_packet(AVPacket *avpkt, int size)
921 {
922     if (size > INT_MAX - FF_INPUT_BUFFER_PADDING_SIZE)
923         return AVERROR(EINVAL);
924
925     if (avpkt->data) {
926         void *destruct = avpkt->destruct;
927
928         if (avpkt->size < size)
929             return AVERROR(EINVAL);
930
931         av_init_packet(avpkt);
932         avpkt->destruct = destruct;
933         avpkt->size     = size;
934         return 0;
935     } else {
936         return av_new_packet(avpkt, size);
937     }
938 }
939
940 /**
941  * Pad last frame with silence.
942  */
943 static int pad_last_frame(AVCodecContext *s, AVFrame **dst, const AVFrame *src)
944 {
945     AVFrame *frame = NULL;
946     uint8_t *buf   = NULL;
947     int ret;
948
949     if (!(frame = avcodec_alloc_frame()))
950         return AVERROR(ENOMEM);
951     *frame = *src;
952
953     if ((ret = av_samples_get_buffer_size(&frame->linesize[0], s->channels,
954                                           s->frame_size, s->sample_fmt, 0)) < 0)
955         goto fail;
956
957     if (!(buf = av_malloc(ret))) {
958         ret = AVERROR(ENOMEM);
959         goto fail;
960     }
961
962     frame->nb_samples = s->frame_size;
963     if ((ret = avcodec_fill_audio_frame(frame, s->channels, s->sample_fmt,
964                                         buf, ret, 0)) < 0)
965         goto fail;
966     if ((ret = av_samples_copy(frame->extended_data, src->extended_data, 0, 0,
967                                src->nb_samples, s->channels, s->sample_fmt)) < 0)
968         goto fail;
969     if ((ret = av_samples_set_silence(frame->extended_data, src->nb_samples,
970                                       frame->nb_samples - src->nb_samples,
971                                       s->channels, s->sample_fmt)) < 0)
972         goto fail;
973
974     *dst = frame;
975
976     return 0;
977
978 fail:
979     if (frame->extended_data != frame->data)
980         av_freep(&frame->extended_data);
981     av_freep(&buf);
982     av_freep(&frame);
983     return ret;
984 }
985
986 int attribute_align_arg avcodec_encode_audio2(AVCodecContext *avctx,
987                                               AVPacket *avpkt,
988                                               const AVFrame *frame,
989                                               int *got_packet_ptr)
990 {
991     AVFrame tmp;
992     AVFrame *padded_frame = NULL;
993     int ret;
994     int user_packet = !!avpkt->data;
995
996     *got_packet_ptr = 0;
997
998     if (!(avctx->codec->capabilities & CODEC_CAP_DELAY) && !frame) {
999         av_free_packet(avpkt);
1000         av_init_packet(avpkt);
1001         return 0;
1002     }
1003
1004     /* ensure that extended_data is properly set */
1005     if (frame && !frame->extended_data) {
1006         if (av_sample_fmt_is_planar(avctx->sample_fmt) &&
1007             avctx->channels > AV_NUM_DATA_POINTERS) {
1008             av_log(avctx, AV_LOG_ERROR, "Encoding to a planar sample format, "
1009                                         "with more than %d channels, but extended_data is not set.\n",
1010                    AV_NUM_DATA_POINTERS);
1011             return AVERROR(EINVAL);
1012         }
1013         av_log(avctx, AV_LOG_WARNING, "extended_data is not set.\n");
1014
1015         tmp = *frame;
1016         tmp.extended_data = tmp.data;
1017         frame = &tmp;
1018     }
1019
1020     /* check for valid frame size */
1021     if (frame) {
1022         if (avctx->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1023             if (frame->nb_samples > avctx->frame_size)
1024                 return AVERROR(EINVAL);
1025         } else if (!(avctx->codec->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE)) {
1026             if (frame->nb_samples < avctx->frame_size &&
1027                 !avctx->internal->last_audio_frame) {
1028                 ret = pad_last_frame(avctx, &padded_frame, frame);
1029                 if (ret < 0)
1030                     return ret;
1031
1032                 frame = padded_frame;
1033                 avctx->internal->last_audio_frame = 1;
1034             }
1035
1036             if (frame->nb_samples != avctx->frame_size) {
1037                 ret = AVERROR(EINVAL);
1038                 goto end;
1039             }
1040         }
1041     }
1042
1043     ret = avctx->codec->encode2(avctx, avpkt, frame, got_packet_ptr);
1044     if (!ret) {
1045         if (*got_packet_ptr) {
1046             if (!(avctx->codec->capabilities & CODEC_CAP_DELAY)) {
1047                 if (avpkt->pts == AV_NOPTS_VALUE)
1048                     avpkt->pts = frame->pts;
1049                 if (!avpkt->duration)
1050                     avpkt->duration = ff_samples_to_time_base(avctx,
1051                                                               frame->nb_samples);
1052             }
1053             avpkt->dts = avpkt->pts;
1054         } else {
1055             avpkt->size = 0;
1056         }
1057
1058         if (!user_packet && avpkt->size) {
1059             uint8_t *new_data = av_realloc(avpkt->data, avpkt->size);
1060             if (new_data)
1061                 avpkt->data = new_data;
1062         }
1063
1064         avctx->frame_number++;
1065     }
1066
1067     if (ret < 0 || !*got_packet_ptr) {
1068         av_free_packet(avpkt);
1069         av_init_packet(avpkt);
1070         goto end;
1071     }
1072
1073     /* NOTE: if we add any audio encoders which output non-keyframe packets,
1074      *       this needs to be moved to the encoders, but for now we can do it
1075      *       here to simplify things */
1076     avpkt->flags |= AV_PKT_FLAG_KEY;
1077
1078 end:
1079     if (padded_frame) {
1080         av_freep(&padded_frame->data[0]);
1081         if (padded_frame->extended_data != padded_frame->data)
1082             av_freep(&padded_frame->extended_data);
1083         av_freep(&padded_frame);
1084     }
1085
1086     return ret;
1087 }
1088
1089 #if FF_API_OLD_ENCODE_AUDIO
1090 int attribute_align_arg avcodec_encode_audio(AVCodecContext *avctx,
1091                                              uint8_t *buf, int buf_size,
1092                                              const short *samples)
1093 {
1094     AVPacket pkt;
1095     AVFrame frame0 = { 0 };
1096     AVFrame *frame;
1097     int ret, samples_size, got_packet;
1098
1099     av_init_packet(&pkt);
1100     pkt.data = buf;
1101     pkt.size = buf_size;
1102
1103     if (samples) {
1104         frame = &frame0;
1105         avcodec_get_frame_defaults(frame);
1106
1107         if (avctx->frame_size) {
1108             frame->nb_samples = avctx->frame_size;
1109         } else {
1110             /* if frame_size is not set, the number of samples must be
1111              * calculated from the buffer size */
1112             int64_t nb_samples;
1113             if (!av_get_bits_per_sample(avctx->codec_id)) {
1114                 av_log(avctx, AV_LOG_ERROR, "avcodec_encode_audio() does not "
1115                                             "support this codec\n");
1116                 return AVERROR(EINVAL);
1117             }
1118             nb_samples = (int64_t)buf_size * 8 /
1119                          (av_get_bits_per_sample(avctx->codec_id) *
1120                           avctx->channels);
1121             if (nb_samples >= INT_MAX)
1122                 return AVERROR(EINVAL);
1123             frame->nb_samples = nb_samples;
1124         }
1125
1126         /* it is assumed that the samples buffer is large enough based on the
1127          * relevant parameters */
1128         samples_size = av_samples_get_buffer_size(NULL, avctx->channels,
1129                                                   frame->nb_samples,
1130                                                   avctx->sample_fmt, 1);
1131         if ((ret = avcodec_fill_audio_frame(frame, avctx->channels,
1132                                             avctx->sample_fmt,
1133                                             (const uint8_t *)samples,
1134                                             samples_size, 1)))
1135             return ret;
1136
1137         /* fabricate frame pts from sample count.
1138          * this is needed because the avcodec_encode_audio() API does not have
1139          * a way for the user to provide pts */
1140         frame->pts = ff_samples_to_time_base(avctx,
1141                                              avctx->internal->sample_count);
1142         avctx->internal->sample_count += frame->nb_samples;
1143     } else {
1144         frame = NULL;
1145     }
1146
1147     got_packet = 0;
1148     ret = avcodec_encode_audio2(avctx, &pkt, frame, &got_packet);
1149     if (!ret && got_packet && avctx->coded_frame) {
1150         avctx->coded_frame->pts       = pkt.pts;
1151         avctx->coded_frame->key_frame = !!(pkt.flags & AV_PKT_FLAG_KEY);
1152     }
1153     /* free any side data since we cannot return it */
1154     if (pkt.side_data_elems > 0) {
1155         int i;
1156         for (i = 0; i < pkt.side_data_elems; i++)
1157             av_free(pkt.side_data[i].data);
1158         av_freep(&pkt.side_data);
1159         pkt.side_data_elems = 0;
1160     }
1161
1162     if (frame && frame->extended_data != frame->data)
1163         av_free(frame->extended_data);
1164
1165     return ret ? ret : pkt.size;
1166 }
1167
1168 #endif
1169
1170 #if FF_API_OLD_ENCODE_VIDEO
1171 int attribute_align_arg avcodec_encode_video(AVCodecContext *avctx, uint8_t *buf, int buf_size,
1172                                              const AVFrame *pict)
1173 {
1174     AVPacket pkt;
1175     int ret, got_packet = 0;
1176
1177     if (buf_size < FF_MIN_BUFFER_SIZE) {
1178         av_log(avctx, AV_LOG_ERROR, "buffer smaller than minimum size\n");
1179         return -1;
1180     }
1181
1182     av_init_packet(&pkt);
1183     pkt.data = buf;
1184     pkt.size = buf_size;
1185
1186     ret = avcodec_encode_video2(avctx, &pkt, pict, &got_packet);
1187     if (!ret && got_packet && avctx->coded_frame) {
1188         avctx->coded_frame->pts       = pkt.pts;
1189         avctx->coded_frame->key_frame = !!(pkt.flags & AV_PKT_FLAG_KEY);
1190     }
1191
1192     /* free any side data since we cannot return it */
1193     if (pkt.side_data_elems > 0) {
1194         int i;
1195         for (i = 0; i < pkt.side_data_elems; i++)
1196             av_free(pkt.side_data[i].data);
1197         av_freep(&pkt.side_data);
1198         pkt.side_data_elems = 0;
1199     }
1200
1201     return ret ? ret : pkt.size;
1202 }
1203
1204 #endif
1205
1206 int attribute_align_arg avcodec_encode_video2(AVCodecContext *avctx,
1207                                               AVPacket *avpkt,
1208                                               const AVFrame *frame,
1209                                               int *got_packet_ptr)
1210 {
1211     int ret;
1212     int user_packet = !!avpkt->data;
1213
1214     *got_packet_ptr = 0;
1215
1216     if (!(avctx->codec->capabilities & CODEC_CAP_DELAY) && !frame) {
1217         av_free_packet(avpkt);
1218         av_init_packet(avpkt);
1219         avpkt->size = 0;
1220         return 0;
1221     }
1222
1223     if (av_image_check_size(avctx->width, avctx->height, 0, avctx))
1224         return AVERROR(EINVAL);
1225
1226     av_assert0(avctx->codec->encode2);
1227
1228     ret = avctx->codec->encode2(avctx, avpkt, frame, got_packet_ptr);
1229     if (!ret) {
1230         if (!*got_packet_ptr)
1231             avpkt->size = 0;
1232         else if (!(avctx->codec->capabilities & CODEC_CAP_DELAY))
1233             avpkt->pts = avpkt->dts = frame->pts;
1234
1235         if (!user_packet && avpkt->size) {
1236             uint8_t *new_data = av_realloc(avpkt->data, avpkt->size);
1237             if (new_data)
1238                 avpkt->data = new_data;
1239         }
1240
1241         avctx->frame_number++;
1242     }
1243
1244     if (ret < 0 || !*got_packet_ptr)
1245         av_free_packet(avpkt);
1246
1247     emms_c();
1248     return ret;
1249 }
1250
1251 int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size,
1252                             const AVSubtitle *sub)
1253 {
1254     int ret;
1255     if (sub->start_display_time) {
1256         av_log(avctx, AV_LOG_ERROR, "start_display_time must be 0.\n");
1257         return -1;
1258     }
1259     if (sub->num_rects == 0 || !sub->rects)
1260         return -1;
1261     ret = avctx->codec->encode_sub(avctx, buf, buf_size, sub);
1262     avctx->frame_number++;
1263     return ret;
1264 }
1265
1266 static void apply_param_change(AVCodecContext *avctx, AVPacket *avpkt)
1267 {
1268     int size = 0;
1269     const uint8_t *data;
1270     uint32_t flags;
1271
1272     if (!(avctx->codec->capabilities & CODEC_CAP_PARAM_CHANGE))
1273         return;
1274
1275     data = av_packet_get_side_data(avpkt, AV_PKT_DATA_PARAM_CHANGE, &size);
1276     if (!data || size < 4)
1277         return;
1278     flags = bytestream_get_le32(&data);
1279     size -= 4;
1280     if (size < 4) /* Required for any of the changes */
1281         return;
1282     if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT) {
1283         avctx->channels = bytestream_get_le32(&data);
1284         size -= 4;
1285     }
1286     if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT) {
1287         if (size < 8)
1288             return;
1289         avctx->channel_layout = bytestream_get_le64(&data);
1290         size -= 8;
1291     }
1292     if (size < 4)
1293         return;
1294     if (flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE) {
1295         avctx->sample_rate = bytestream_get_le32(&data);
1296         size -= 4;
1297     }
1298     if (flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS) {
1299         if (size < 8)
1300             return;
1301         avctx->width  = bytestream_get_le32(&data);
1302         avctx->height = bytestream_get_le32(&data);
1303         avcodec_set_dimensions(avctx, avctx->width, avctx->height);
1304         size -= 8;
1305     }
1306 }
1307
1308 int attribute_align_arg avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
1309                                               int *got_picture_ptr,
1310                                               AVPacket *avpkt)
1311 {
1312     int ret;
1313
1314     *got_picture_ptr = 0;
1315     if ((avctx->coded_width || avctx->coded_height) && av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx))
1316         return -1;
1317
1318     avctx->pkt = avpkt;
1319     apply_param_change(avctx, avpkt);
1320
1321     avcodec_get_frame_defaults(picture);
1322
1323     if ((avctx->codec->capabilities & CODEC_CAP_DELAY) || avpkt->size || (avctx->active_thread_type & FF_THREAD_FRAME)) {
1324         if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME)
1325             ret = ff_thread_decode_frame(avctx, picture, got_picture_ptr,
1326                                          avpkt);
1327         else {
1328             ret = avctx->codec->decode(avctx, picture, got_picture_ptr,
1329                                        avpkt);
1330             picture->pkt_dts             = avpkt->dts;
1331             picture->sample_aspect_ratio = avctx->sample_aspect_ratio;
1332             picture->width               = avctx->width;
1333             picture->height              = avctx->height;
1334             picture->format              = avctx->pix_fmt;
1335         }
1336
1337         emms_c(); //needed to avoid an emms_c() call before every return;
1338
1339         if (*got_picture_ptr)
1340             avctx->frame_number++;
1341     } else
1342         ret = 0;
1343
1344     /* many decoders assign whole AVFrames, thus overwriting extended_data;
1345      * make sure it's set correctly */
1346     picture->extended_data = picture->data;
1347
1348     return ret;
1349 }
1350
1351 #if FF_API_OLD_DECODE_AUDIO
1352 int attribute_align_arg avcodec_decode_audio3(AVCodecContext *avctx, int16_t *samples,
1353                                               int *frame_size_ptr,
1354                                               AVPacket *avpkt)
1355 {
1356     AVFrame frame = {0};
1357     int ret, got_frame = 0;
1358
1359     if (avctx->get_buffer != avcodec_default_get_buffer) {
1360         av_log(avctx, AV_LOG_ERROR, "Custom get_buffer() for use with"
1361                                     "avcodec_decode_audio3() detected. Overriding with avcodec_default_get_buffer\n");
1362         av_log(avctx, AV_LOG_ERROR, "Please port your application to "
1363                                     "avcodec_decode_audio4()\n");
1364         avctx->get_buffer = avcodec_default_get_buffer;
1365     }
1366
1367     ret = avcodec_decode_audio4(avctx, &frame, &got_frame, avpkt);
1368
1369     if (ret >= 0 && got_frame) {
1370         int ch, plane_size;
1371         int planar    = av_sample_fmt_is_planar(avctx->sample_fmt);
1372         int data_size = av_samples_get_buffer_size(&plane_size, avctx->channels,
1373                                                    frame.nb_samples,
1374                                                    avctx->sample_fmt, 1);
1375         if (*frame_size_ptr < data_size) {
1376             av_log(avctx, AV_LOG_ERROR, "output buffer size is too small for "
1377                                         "the current frame (%d < %d)\n", *frame_size_ptr, data_size);
1378             return AVERROR(EINVAL);
1379         }
1380
1381         memcpy(samples, frame.extended_data[0], plane_size);
1382
1383         if (planar && avctx->channels > 1) {
1384             uint8_t *out = ((uint8_t *)samples) + plane_size;
1385             for (ch = 1; ch < avctx->channels; ch++) {
1386                 memcpy(out, frame.extended_data[ch], plane_size);
1387                 out += plane_size;
1388             }
1389         }
1390         *frame_size_ptr = data_size;
1391     } else {
1392         *frame_size_ptr = 0;
1393     }
1394     return ret;
1395 }
1396
1397 #endif
1398
1399 int attribute_align_arg avcodec_decode_audio4(AVCodecContext *avctx,
1400                                               AVFrame *frame,
1401                                               int *got_frame_ptr,
1402                                               AVPacket *avpkt)
1403 {
1404     int planar, channels;
1405     int ret = 0;
1406
1407     *got_frame_ptr = 0;
1408
1409     avctx->pkt = avpkt;
1410
1411     if (!avpkt->data && avpkt->size) {
1412         av_log(avctx, AV_LOG_ERROR, "invalid packet: NULL data, size != 0\n");
1413         return AVERROR(EINVAL);
1414     }
1415
1416     apply_param_change(avctx, avpkt);
1417
1418     avcodec_get_frame_defaults(frame);
1419
1420     if ((avctx->codec->capabilities & CODEC_CAP_DELAY) || avpkt->size) {
1421         ret = avctx->codec->decode(avctx, frame, got_frame_ptr, avpkt);
1422         if (ret >= 0 && *got_frame_ptr) {
1423             avctx->frame_number++;
1424             frame->pkt_dts = avpkt->dts;
1425             if (frame->format == AV_SAMPLE_FMT_NONE)
1426                 frame->format = avctx->sample_fmt;
1427         }
1428     }
1429
1430     /* many decoders assign whole AVFrames, thus overwriting extended_data;
1431      * make sure it's set correctly; assume decoders that actually use
1432      * extended_data are doing it correctly */
1433     planar   = av_sample_fmt_is_planar(frame->format);
1434     channels = av_get_channel_layout_nb_channels(frame->channel_layout);
1435     if (!(planar && channels > AV_NUM_DATA_POINTERS))
1436         frame->extended_data = frame->data;
1437
1438     return ret;
1439 }
1440
1441 int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub,
1442                              int *got_sub_ptr,
1443                              AVPacket *avpkt)
1444 {
1445     int ret;
1446
1447     avctx->pkt = avpkt;
1448     *got_sub_ptr = 0;
1449     ret = avctx->codec->decode(avctx, sub, got_sub_ptr, avpkt);
1450     if (*got_sub_ptr)
1451         avctx->frame_number++;
1452     return ret;
1453 }
1454
1455 void avsubtitle_free(AVSubtitle *sub)
1456 {
1457     int i;
1458
1459     for (i = 0; i < sub->num_rects; i++) {
1460         av_freep(&sub->rects[i]->pict.data[0]);
1461         av_freep(&sub->rects[i]->pict.data[1]);
1462         av_freep(&sub->rects[i]->pict.data[2]);
1463         av_freep(&sub->rects[i]->pict.data[3]);
1464         av_freep(&sub->rects[i]->text);
1465         av_freep(&sub->rects[i]->ass);
1466         av_freep(&sub->rects[i]);
1467     }
1468
1469     av_freep(&sub->rects);
1470
1471     memset(sub, 0, sizeof(AVSubtitle));
1472 }
1473
1474 av_cold int avcodec_close(AVCodecContext *avctx)
1475 {
1476     /* If there is a user-supplied mutex locking routine, call it. */
1477     if (ff_lockmgr_cb) {
1478         if ((*ff_lockmgr_cb)(&codec_mutex, AV_LOCK_OBTAIN))
1479             return -1;
1480     }
1481
1482     entangled_thread_counter++;
1483     if (entangled_thread_counter != 1) {
1484         av_log(avctx, AV_LOG_ERROR, "insufficient thread locking around avcodec_open/close()\n");
1485         entangled_thread_counter--;
1486         return -1;
1487     }
1488
1489     if (avcodec_is_open(avctx)) {
1490         if (HAVE_THREADS && avctx->thread_opaque)
1491             ff_thread_free(avctx);
1492         if (avctx->codec && avctx->codec->close)
1493             avctx->codec->close(avctx);
1494         avcodec_default_free_buffers(avctx);
1495         avctx->coded_frame = NULL;
1496         av_freep(&avctx->internal);
1497     }
1498
1499     if (avctx->priv_data && avctx->codec && avctx->codec->priv_class)
1500         av_opt_free(avctx->priv_data);
1501     av_opt_free(avctx);
1502     av_freep(&avctx->priv_data);
1503     if (av_codec_is_encoder(avctx->codec))
1504         av_freep(&avctx->extradata);
1505     avctx->codec = NULL;
1506     avctx->active_thread_type = 0;
1507     entangled_thread_counter--;
1508
1509     /* Release any user-supplied mutex. */
1510     if (ff_lockmgr_cb) {
1511         (*ff_lockmgr_cb)(&codec_mutex, AV_LOCK_RELEASE);
1512     }
1513     return 0;
1514 }
1515
1516 static AVCodec *find_encdec(enum AVCodecID id, int encoder)
1517 {
1518     AVCodec *p, *experimental = NULL;
1519     p = first_avcodec;
1520     while (p) {
1521         if ((encoder ? av_codec_is_encoder(p) : av_codec_is_decoder(p)) &&
1522             p->id == id) {
1523             if (p->capabilities & CODEC_CAP_EXPERIMENTAL && !experimental) {
1524                 experimental = p;
1525             } else
1526                 return p;
1527         }
1528         p = p->next;
1529     }
1530     return experimental;
1531 }
1532
1533 AVCodec *avcodec_find_encoder(enum AVCodecID id)
1534 {
1535     return find_encdec(id, 1);
1536 }
1537
1538 AVCodec *avcodec_find_encoder_by_name(const char *name)
1539 {
1540     AVCodec *p;
1541     if (!name)
1542         return NULL;
1543     p = first_avcodec;
1544     while (p) {
1545         if (av_codec_is_encoder(p) && strcmp(name, p->name) == 0)
1546             return p;
1547         p = p->next;
1548     }
1549     return NULL;
1550 }
1551
1552 AVCodec *avcodec_find_decoder(enum AVCodecID id)
1553 {
1554     return find_encdec(id, 0);
1555 }
1556
1557 AVCodec *avcodec_find_decoder_by_name(const char *name)
1558 {
1559     AVCodec *p;
1560     if (!name)
1561         return NULL;
1562     p = first_avcodec;
1563     while (p) {
1564         if (av_codec_is_decoder(p) && strcmp(name, p->name) == 0)
1565             return p;
1566         p = p->next;
1567     }
1568     return NULL;
1569 }
1570
1571 static int get_bit_rate(AVCodecContext *ctx)
1572 {
1573     int bit_rate;
1574     int bits_per_sample;
1575
1576     switch (ctx->codec_type) {
1577     case AVMEDIA_TYPE_VIDEO:
1578     case AVMEDIA_TYPE_DATA:
1579     case AVMEDIA_TYPE_SUBTITLE:
1580     case AVMEDIA_TYPE_ATTACHMENT:
1581         bit_rate = ctx->bit_rate;
1582         break;
1583     case AVMEDIA_TYPE_AUDIO:
1584         bits_per_sample = av_get_bits_per_sample(ctx->codec_id);
1585         bit_rate = bits_per_sample ? ctx->sample_rate * ctx->channels * bits_per_sample : ctx->bit_rate;
1586         break;
1587     default:
1588         bit_rate = 0;
1589         break;
1590     }
1591     return bit_rate;
1592 }
1593
1594 size_t av_get_codec_tag_string(char *buf, size_t buf_size, unsigned int codec_tag)
1595 {
1596     int i, len, ret = 0;
1597
1598     for (i = 0; i < 4; i++) {
1599         len = snprintf(buf, buf_size,
1600                        isprint(codec_tag & 0xFF) ? "%c" : "[%d]", codec_tag & 0xFF);
1601         buf        += len;
1602         buf_size    = buf_size > len ? buf_size - len : 0;
1603         ret        += len;
1604         codec_tag >>= 8;
1605     }
1606     return ret;
1607 }
1608
1609 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
1610 {
1611     const char *codec_name;
1612     const char *profile = NULL;
1613     const AVCodec *p;
1614     char buf1[32];
1615     int bitrate;
1616     AVRational display_aspect_ratio;
1617
1618     if (enc->codec)
1619         p = enc->codec;
1620     else if (encode)
1621         p = avcodec_find_encoder(enc->codec_id);
1622     else
1623         p = avcodec_find_decoder(enc->codec_id);
1624
1625     if (p) {
1626         codec_name = p->name;
1627         profile = av_get_profile_name(p, enc->profile);
1628     } else if (enc->codec_id == AV_CODEC_ID_MPEG2TS) {
1629         /* fake mpeg2 transport stream codec (currently not
1630          * registered) */
1631         codec_name = "mpeg2ts";
1632     } else if (enc->codec_name[0] != '\0') {
1633         codec_name = enc->codec_name;
1634     } else {
1635         /* output avi tags */
1636         char tag_buf[32];
1637         av_get_codec_tag_string(tag_buf, sizeof(tag_buf), enc->codec_tag);
1638         snprintf(buf1, sizeof(buf1), "%s / 0x%04X", tag_buf, enc->codec_tag);
1639         codec_name = buf1;
1640     }
1641
1642     switch (enc->codec_type) {
1643     case AVMEDIA_TYPE_VIDEO:
1644         snprintf(buf, buf_size,
1645                  "Video: %s%s",
1646                  codec_name, enc->mb_decision ? " (hq)" : "");
1647         if (profile)
1648             snprintf(buf + strlen(buf), buf_size - strlen(buf),
1649                      " (%s)", profile);
1650         if (enc->pix_fmt != AV_PIX_FMT_NONE) {
1651             snprintf(buf + strlen(buf), buf_size - strlen(buf),
1652                      ", %s",
1653                      av_get_pix_fmt_name(enc->pix_fmt));
1654         }
1655         if (enc->width) {
1656             snprintf(buf + strlen(buf), buf_size - strlen(buf),
1657                      ", %dx%d",
1658                      enc->width, enc->height);
1659             if (enc->sample_aspect_ratio.num) {
1660                 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
1661                           enc->width * enc->sample_aspect_ratio.num,
1662                           enc->height * enc->sample_aspect_ratio.den,
1663                           1024 * 1024);
1664                 snprintf(buf + strlen(buf), buf_size - strlen(buf),
1665                          " [PAR %d:%d DAR %d:%d]",
1666                          enc->sample_aspect_ratio.num, enc->sample_aspect_ratio.den,
1667                          display_aspect_ratio.num, display_aspect_ratio.den);
1668             }
1669             if (av_log_get_level() >= AV_LOG_DEBUG) {
1670                 int g = av_gcd(enc->time_base.num, enc->time_base.den);
1671                 snprintf(buf + strlen(buf), buf_size - strlen(buf),
1672                          ", %d/%d",
1673                          enc->time_base.num / g, enc->time_base.den / g);
1674             }
1675         }
1676         if (encode) {
1677             snprintf(buf + strlen(buf), buf_size - strlen(buf),
1678                      ", q=%d-%d", enc->qmin, enc->qmax);
1679         }
1680         break;
1681     case AVMEDIA_TYPE_AUDIO:
1682         snprintf(buf, buf_size,
1683                  "Audio: %s",
1684                  codec_name);
1685         if (profile)
1686             snprintf(buf + strlen(buf), buf_size - strlen(buf),
1687                      " (%s)", profile);
1688         if (enc->sample_rate) {
1689             snprintf(buf + strlen(buf), buf_size - strlen(buf),
1690                      ", %d Hz", enc->sample_rate);
1691         }
1692         av_strlcat(buf, ", ", buf_size);
1693         av_get_channel_layout_string(buf + strlen(buf), buf_size - strlen(buf), enc->channels, enc->channel_layout);
1694         if (enc->sample_fmt != AV_SAMPLE_FMT_NONE) {
1695             snprintf(buf + strlen(buf), buf_size - strlen(buf),
1696                      ", %s", av_get_sample_fmt_name(enc->sample_fmt));
1697         }
1698         break;
1699     case AVMEDIA_TYPE_DATA:
1700         snprintf(buf, buf_size, "Data: %s", codec_name);
1701         break;
1702     case AVMEDIA_TYPE_SUBTITLE:
1703         snprintf(buf, buf_size, "Subtitle: %s", codec_name);
1704         break;
1705     case AVMEDIA_TYPE_ATTACHMENT:
1706         snprintf(buf, buf_size, "Attachment: %s", codec_name);
1707         break;
1708     default:
1709         snprintf(buf, buf_size, "Invalid Codec type %d", enc->codec_type);
1710         return;
1711     }
1712     if (encode) {
1713         if (enc->flags & CODEC_FLAG_PASS1)
1714             snprintf(buf + strlen(buf), buf_size - strlen(buf),
1715                      ", pass 1");
1716         if (enc->flags & CODEC_FLAG_PASS2)
1717             snprintf(buf + strlen(buf), buf_size - strlen(buf),
1718                      ", pass 2");
1719     }
1720     bitrate = get_bit_rate(enc);
1721     if (bitrate != 0) {
1722         snprintf(buf + strlen(buf), buf_size - strlen(buf),
1723                  ", %d kb/s", bitrate / 1000);
1724     }
1725 }
1726
1727 const char *av_get_profile_name(const AVCodec *codec, int profile)
1728 {
1729     const AVProfile *p;
1730     if (profile == FF_PROFILE_UNKNOWN || !codec->profiles)
1731         return NULL;
1732
1733     for (p = codec->profiles; p->profile != FF_PROFILE_UNKNOWN; p++)
1734         if (p->profile == profile)
1735             return p->name;
1736
1737     return NULL;
1738 }
1739
1740 unsigned avcodec_version(void)
1741 {
1742     return LIBAVCODEC_VERSION_INT;
1743 }
1744
1745 const char *avcodec_configuration(void)
1746 {
1747     return LIBAV_CONFIGURATION;
1748 }
1749
1750 const char *avcodec_license(void)
1751 {
1752 #define LICENSE_PREFIX "libavcodec license: "
1753     return LICENSE_PREFIX LIBAV_LICENSE + sizeof(LICENSE_PREFIX) - 1;
1754 }
1755
1756 void avcodec_flush_buffers(AVCodecContext *avctx)
1757 {
1758     if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME)
1759         ff_thread_flush(avctx);
1760     else if (avctx->codec->flush)
1761         avctx->codec->flush(avctx);
1762 }
1763
1764 static void video_free_buffers(AVCodecContext *s)
1765 {
1766     AVCodecInternal *avci = s->internal;
1767     int i, j;
1768
1769     if (!avci->buffer)
1770         return;
1771
1772     if (avci->buffer_count)
1773         av_log(s, AV_LOG_WARNING, "Found %i unreleased buffers!\n",
1774                avci->buffer_count);
1775     for (i = 0; i < INTERNAL_BUFFER_SIZE; i++) {
1776         InternalBuffer *buf = &avci->buffer[i];
1777         for (j = 0; j < 4; j++) {
1778             av_freep(&buf->base[j]);
1779             buf->data[j] = NULL;
1780         }
1781     }
1782     av_freep(&avci->buffer);
1783
1784     avci->buffer_count = 0;
1785 }
1786
1787 static void audio_free_buffers(AVCodecContext *avctx)
1788 {
1789     AVCodecInternal *avci = avctx->internal;
1790     InternalBuffer *buf;
1791
1792     if (!avci->buffer)
1793         return;
1794     buf = avci->buffer;
1795
1796     if (buf->extended_data) {
1797         av_free(buf->extended_data[0]);
1798         if (buf->extended_data != buf->data)
1799             av_free(buf->extended_data);
1800     }
1801     av_freep(&avci->buffer);
1802 }
1803
1804 void avcodec_default_free_buffers(AVCodecContext *avctx)
1805 {
1806     switch (avctx->codec_type) {
1807     case AVMEDIA_TYPE_VIDEO:
1808         video_free_buffers(avctx);
1809         break;
1810     case AVMEDIA_TYPE_AUDIO:
1811         audio_free_buffers(avctx);
1812         break;
1813     default:
1814         break;
1815     }
1816 }
1817
1818 int av_get_exact_bits_per_sample(enum AVCodecID codec_id)
1819 {
1820     switch (codec_id) {
1821     case AV_CODEC_ID_ADPCM_CT:
1822     case AV_CODEC_ID_ADPCM_IMA_APC:
1823     case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:
1824     case AV_CODEC_ID_ADPCM_IMA_WS:
1825     case AV_CODEC_ID_ADPCM_G722:
1826     case AV_CODEC_ID_ADPCM_YAMAHA:
1827         return 4;
1828     case AV_CODEC_ID_PCM_ALAW:
1829     case AV_CODEC_ID_PCM_MULAW:
1830     case AV_CODEC_ID_PCM_S8:
1831     case AV_CODEC_ID_PCM_U8:
1832     case AV_CODEC_ID_PCM_ZORK:
1833         return 8;
1834     case AV_CODEC_ID_PCM_S16BE:
1835     case AV_CODEC_ID_PCM_S16LE:
1836     case AV_CODEC_ID_PCM_S16LE_PLANAR:
1837     case AV_CODEC_ID_PCM_U16BE:
1838     case AV_CODEC_ID_PCM_U16LE:
1839         return 16;
1840     case AV_CODEC_ID_PCM_S24DAUD:
1841     case AV_CODEC_ID_PCM_S24BE:
1842     case AV_CODEC_ID_PCM_S24LE:
1843     case AV_CODEC_ID_PCM_U24BE:
1844     case AV_CODEC_ID_PCM_U24LE:
1845         return 24;
1846     case AV_CODEC_ID_PCM_S32BE:
1847     case AV_CODEC_ID_PCM_S32LE:
1848     case AV_CODEC_ID_PCM_U32BE:
1849     case AV_CODEC_ID_PCM_U32LE:
1850     case AV_CODEC_ID_PCM_F32BE:
1851     case AV_CODEC_ID_PCM_F32LE:
1852         return 32;
1853     case AV_CODEC_ID_PCM_F64BE:
1854     case AV_CODEC_ID_PCM_F64LE:
1855         return 64;
1856     default:
1857         return 0;
1858     }
1859 }
1860
1861 int av_get_bits_per_sample(enum AVCodecID codec_id)
1862 {
1863     switch (codec_id) {
1864     case AV_CODEC_ID_ADPCM_SBPRO_2:
1865         return 2;
1866     case AV_CODEC_ID_ADPCM_SBPRO_3:
1867         return 3;
1868     case AV_CODEC_ID_ADPCM_SBPRO_4:
1869     case AV_CODEC_ID_ADPCM_IMA_WAV:
1870     case AV_CODEC_ID_ADPCM_IMA_QT:
1871     case AV_CODEC_ID_ADPCM_SWF:
1872     case AV_CODEC_ID_ADPCM_MS:
1873         return 4;
1874     default:
1875         return av_get_exact_bits_per_sample(codec_id);
1876     }
1877 }
1878
1879 int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
1880 {
1881     int id, sr, ch, ba, tag, bps;
1882
1883     id  = avctx->codec_id;
1884     sr  = avctx->sample_rate;
1885     ch  = avctx->channels;
1886     ba  = avctx->block_align;
1887     tag = avctx->codec_tag;
1888     bps = av_get_exact_bits_per_sample(avctx->codec_id);
1889
1890     /* codecs with an exact constant bits per sample */
1891     if (bps > 0 && ch > 0 && frame_bytes > 0)
1892         return (frame_bytes * 8) / (bps * ch);
1893     bps = avctx->bits_per_coded_sample;
1894
1895     /* codecs with a fixed packet duration */
1896     switch (id) {
1897     case AV_CODEC_ID_ADPCM_ADX:    return   32;
1898     case AV_CODEC_ID_ADPCM_IMA_QT: return   64;
1899     case AV_CODEC_ID_ADPCM_EA_XAS: return  128;
1900     case AV_CODEC_ID_AMR_NB:
1901     case AV_CODEC_ID_GSM:
1902     case AV_CODEC_ID_QCELP:
1903     case AV_CODEC_ID_RA_144:
1904     case AV_CODEC_ID_RA_288:       return  160;
1905     case AV_CODEC_ID_IMC:          return  256;
1906     case AV_CODEC_ID_AMR_WB:
1907     case AV_CODEC_ID_GSM_MS:       return  320;
1908     case AV_CODEC_ID_MP1:          return  384;
1909     case AV_CODEC_ID_ATRAC1:       return  512;
1910     case AV_CODEC_ID_ATRAC3:       return 1024;
1911     case AV_CODEC_ID_MP2:
1912     case AV_CODEC_ID_MUSEPACK7:    return 1152;
1913     case AV_CODEC_ID_AC3:          return 1536;
1914     }
1915
1916     if (sr > 0) {
1917         /* calc from sample rate */
1918         if (id == AV_CODEC_ID_TTA)
1919             return 256 * sr / 245;
1920
1921         if (ch > 0) {
1922             /* calc from sample rate and channels */
1923             if (id == AV_CODEC_ID_BINKAUDIO_DCT)
1924                 return (480 << (sr / 22050)) / ch;
1925         }
1926     }
1927
1928     if (ba > 0) {
1929         /* calc from block_align */
1930         if (id == AV_CODEC_ID_SIPR) {
1931             switch (ba) {
1932             case 20: return 160;
1933             case 19: return 144;
1934             case 29: return 288;
1935             case 37: return 480;
1936             }
1937         } else if (id == AV_CODEC_ID_ILBC) {
1938             switch (ba) {
1939             case 38: return 160;
1940             case 50: return 240;
1941             }
1942         }
1943     }
1944
1945     if (frame_bytes > 0) {
1946         /* calc from frame_bytes only */
1947         if (id == AV_CODEC_ID_TRUESPEECH)
1948             return 240 * (frame_bytes / 32);
1949         if (id == AV_CODEC_ID_NELLYMOSER)
1950             return 256 * (frame_bytes / 64);
1951
1952         if (bps > 0) {
1953             /* calc from frame_bytes and bits_per_coded_sample */
1954             if (id == AV_CODEC_ID_ADPCM_G726)
1955                 return frame_bytes * 8 / bps;
1956         }
1957
1958         if (ch > 0) {
1959             /* calc from frame_bytes and channels */
1960             switch (id) {
1961             case AV_CODEC_ID_ADPCM_4XM:
1962             case AV_CODEC_ID_ADPCM_IMA_ISS:
1963                 return (frame_bytes - 4 * ch) * 2 / ch;
1964             case AV_CODEC_ID_ADPCM_IMA_SMJPEG:
1965                 return (frame_bytes - 4) * 2 / ch;
1966             case AV_CODEC_ID_ADPCM_IMA_AMV:
1967                 return (frame_bytes - 8) * 2 / ch;
1968             case AV_CODEC_ID_ADPCM_XA:
1969                 return (frame_bytes / 128) * 224 / ch;
1970             case AV_CODEC_ID_INTERPLAY_DPCM:
1971                 return (frame_bytes - 6 - ch) / ch;
1972             case AV_CODEC_ID_ROQ_DPCM:
1973                 return (frame_bytes - 8) / ch;
1974             case AV_CODEC_ID_XAN_DPCM:
1975                 return (frame_bytes - 2 * ch) / ch;
1976             case AV_CODEC_ID_MACE3:
1977                 return 3 * frame_bytes / ch;
1978             case AV_CODEC_ID_MACE6:
1979                 return 6 * frame_bytes / ch;
1980             case AV_CODEC_ID_PCM_LXF:
1981                 return 2 * (frame_bytes / (5 * ch));
1982             }
1983
1984             if (tag) {
1985                 /* calc from frame_bytes, channels, and codec_tag */
1986                 if (id == AV_CODEC_ID_SOL_DPCM) {
1987                     if (tag == 3)
1988                         return frame_bytes / ch;
1989                     else
1990                         return frame_bytes * 2 / ch;
1991                 }
1992             }
1993
1994             if (ba > 0) {
1995                 /* calc from frame_bytes, channels, and block_align */
1996                 int blocks = frame_bytes / ba;
1997                 switch (avctx->codec_id) {
1998                 case AV_CODEC_ID_ADPCM_IMA_WAV:
1999                     return blocks * (1 + (ba - 4 * ch) / (4 * ch) * 8);
2000                 case AV_CODEC_ID_ADPCM_IMA_DK3:
2001                     return blocks * (((ba - 16) * 2 / 3 * 4) / ch);
2002                 case AV_CODEC_ID_ADPCM_IMA_DK4:
2003                     return blocks * (1 + (ba - 4 * ch) * 2 / ch);
2004                 case AV_CODEC_ID_ADPCM_MS:
2005                     return blocks * (2 + (ba - 7 * ch) * 2 / ch);
2006                 }
2007             }
2008
2009             if (bps > 0) {
2010                 /* calc from frame_bytes, channels, and bits_per_coded_sample */
2011                 switch (avctx->codec_id) {
2012                 case AV_CODEC_ID_PCM_DVD:
2013                     return 2 * (frame_bytes / ((bps * 2 / 8) * ch));
2014                 case AV_CODEC_ID_PCM_BLURAY:
2015                     return frame_bytes / ((FFALIGN(ch, 2) * bps) / 8);
2016                 case AV_CODEC_ID_S302M:
2017                     return 2 * (frame_bytes / ((bps + 4) / 4)) / ch;
2018                 }
2019             }
2020         }
2021     }
2022
2023     return 0;
2024 }
2025
2026 #if !HAVE_THREADS
2027 int ff_thread_init(AVCodecContext *s)
2028 {
2029     return -1;
2030 }
2031
2032 #endif
2033
2034 unsigned int av_xiphlacing(unsigned char *s, unsigned int v)
2035 {
2036     unsigned int n = 0;
2037
2038     while (v >= 0xff) {
2039         *s++ = 0xff;
2040         v -= 0xff;
2041         n++;
2042     }
2043     *s = v;
2044     n++;
2045     return n;
2046 }
2047
2048 int ff_match_2uint16(const uint16_t(*tab)[2], int size, int a, int b)
2049 {
2050     int i;
2051     for (i = 0; i < size && !(tab[i][0] == a && tab[i][1] == b); i++) ;
2052     return i;
2053 }
2054
2055 void av_log_missing_feature(void *avc, const char *feature, int want_sample)
2056 {
2057     av_log(avc, AV_LOG_WARNING, "%s is not implemented. Update your Libav "
2058             "version to the newest one from Git. If the problem still "
2059             "occurs, it means that your file has a feature which has not "
2060             "been implemented.\n", feature);
2061     if(want_sample)
2062         av_log_ask_for_sample(avc, NULL);
2063 }
2064
2065 void av_log_ask_for_sample(void *avc, const char *msg, ...)
2066 {
2067     va_list argument_list;
2068
2069     va_start(argument_list, msg);
2070
2071     if (msg)
2072         av_vlog(avc, AV_LOG_WARNING, msg, argument_list);
2073     av_log(avc, AV_LOG_WARNING, "If you want to help, upload a sample "
2074             "of this file to ftp://upload.libav.org/incoming/ "
2075             "and contact the libav-devel mailing list.\n");
2076
2077     va_end(argument_list);
2078 }
2079
2080 static AVHWAccel *first_hwaccel = NULL;
2081
2082 void av_register_hwaccel(AVHWAccel *hwaccel)
2083 {
2084     AVHWAccel **p = &first_hwaccel;
2085     while (*p)
2086         p = &(*p)->next;
2087     *p = hwaccel;
2088     hwaccel->next = NULL;
2089 }
2090
2091 AVHWAccel *av_hwaccel_next(AVHWAccel *hwaccel)
2092 {
2093     return hwaccel ? hwaccel->next : first_hwaccel;
2094 }
2095
2096 AVHWAccel *ff_find_hwaccel(enum AVCodecID codec_id, enum AVPixelFormat pix_fmt)
2097 {
2098     AVHWAccel *hwaccel = NULL;
2099
2100     while ((hwaccel = av_hwaccel_next(hwaccel)))
2101         if (hwaccel->id == codec_id
2102             && hwaccel->pix_fmt == pix_fmt)
2103             return hwaccel;
2104     return NULL;
2105 }
2106
2107 int av_lockmgr_register(int (*cb)(void **mutex, enum AVLockOp op))
2108 {
2109     if (ff_lockmgr_cb) {
2110         if (ff_lockmgr_cb(&codec_mutex, AV_LOCK_DESTROY))
2111             return -1;
2112         if (ff_lockmgr_cb(&avformat_mutex, AV_LOCK_DESTROY))
2113             return -1;
2114     }
2115
2116     ff_lockmgr_cb = cb;
2117
2118     if (ff_lockmgr_cb) {
2119         if (ff_lockmgr_cb(&codec_mutex, AV_LOCK_CREATE))
2120             return -1;
2121         if (ff_lockmgr_cb(&avformat_mutex, AV_LOCK_CREATE))
2122             return -1;
2123     }
2124     return 0;
2125 }
2126
2127 int avpriv_lock_avformat(void)
2128 {
2129     if (ff_lockmgr_cb) {
2130         if ((*ff_lockmgr_cb)(&avformat_mutex, AV_LOCK_OBTAIN))
2131             return -1;
2132     }
2133     return 0;
2134 }
2135
2136 int avpriv_unlock_avformat(void)
2137 {
2138     if (ff_lockmgr_cb) {
2139         if ((*ff_lockmgr_cb)(&avformat_mutex, AV_LOCK_RELEASE))
2140             return -1;
2141     }
2142     return 0;
2143 }
2144
2145 unsigned int avpriv_toupper4(unsigned int x)
2146 {
2147     return toupper(x & 0xFF)
2148            + (toupper((x >> 8) & 0xFF) << 8)
2149            + (toupper((x >> 16) & 0xFF) << 16)
2150            + (toupper((x >> 24) & 0xFF) << 24);
2151 }
2152
2153 #if !HAVE_THREADS
2154
2155 int ff_thread_get_buffer(AVCodecContext *avctx, AVFrame *f)
2156 {
2157     f->owner = avctx;
2158     return ff_get_buffer(avctx, f);
2159 }
2160
2161 void ff_thread_release_buffer(AVCodecContext *avctx, AVFrame *f)
2162 {
2163     f->owner->release_buffer(f->owner, f);
2164 }
2165
2166 void ff_thread_finish_setup(AVCodecContext *avctx)
2167 {
2168 }
2169
2170 void ff_thread_report_progress(AVFrame *f, int progress, int field)
2171 {
2172 }
2173
2174 void ff_thread_await_progress(AVFrame *f, int progress, int field)
2175 {
2176 }
2177
2178 #endif
2179
2180 enum AVMediaType avcodec_get_type(enum AVCodecID codec_id)
2181 {
2182     if (codec_id <= AV_CODEC_ID_NONE)
2183         return AVMEDIA_TYPE_UNKNOWN;
2184     else if (codec_id < AV_CODEC_ID_FIRST_AUDIO)
2185         return AVMEDIA_TYPE_VIDEO;
2186     else if (codec_id < AV_CODEC_ID_FIRST_SUBTITLE)
2187         return AVMEDIA_TYPE_AUDIO;
2188     else if (codec_id < AV_CODEC_ID_FIRST_UNKNOWN)
2189         return AVMEDIA_TYPE_SUBTITLE;
2190
2191     return AVMEDIA_TYPE_UNKNOWN;
2192 }
2193
2194 int avcodec_is_open(AVCodecContext *s)
2195 {
2196     return !!s->internal;
2197 }