Remove usage of deprecated libavcodec/audioconvert.h functions.
[ffmpeg.git] / libavcodec / utils.c
1 /*
2  * utils for libavcodec
3  * Copyright (c) 2001 Fabrice Bellard
4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22
23 /**
24  * @file
25  * utils.
26  */
27
28 #include "libavutil/avstring.h"
29 #include "libavutil/integer.h"
30 #include "libavutil/crc.h"
31 #include "libavutil/pixdesc.h"
32 #include "libavcore/imgutils.h"
33 #include "libavcore/samplefmt.h"
34 #include "avcodec.h"
35 #include "dsputil.h"
36 #include "libavutil/opt.h"
37 #include "imgconvert.h"
38 #include "audioconvert.h"
39 #include "internal.h"
40 #include <stdlib.h>
41 #include <stdarg.h>
42 #include <limits.h>
43 #include <float.h>
44
45 static int volatile entangled_thread_counter=0;
46 int (*ff_lockmgr_cb)(void **mutex, enum AVLockOp op);
47 static void *codec_mutex;
48
49 void *av_fast_realloc(void *ptr, unsigned int *size, unsigned int min_size)
50 {
51     if(min_size < *size)
52         return ptr;
53
54     *size= FFMAX(17*min_size/16 + 32, min_size);
55
56     ptr= av_realloc(ptr, *size);
57     if(!ptr) //we could set this to the unmodified min_size but this is safer if the user lost the ptr and uses NULL now
58         *size= 0;
59
60     return ptr;
61 }
62
63 void av_fast_malloc(void *ptr, unsigned int *size, unsigned int min_size)
64 {
65     void **p = ptr;
66     if (min_size < *size)
67         return;
68     *size= FFMAX(17*min_size/16 + 32, min_size);
69     av_free(*p);
70     *p = av_malloc(*size);
71     if (!*p) *size = 0;
72 }
73
74 /* encoder management */
75 static AVCodec *first_avcodec = NULL;
76
77 AVCodec *av_codec_next(AVCodec *c){
78     if(c) return c->next;
79     else  return first_avcodec;
80 }
81
82 void avcodec_register(AVCodec *codec)
83 {
84     AVCodec **p;
85     avcodec_init();
86     p = &first_avcodec;
87     while (*p != NULL) p = &(*p)->next;
88     *p = codec;
89     codec->next = NULL;
90 }
91
92 #if LIBAVCODEC_VERSION_MAJOR < 53
93 void register_avcodec(AVCodec *codec)
94 {
95     avcodec_register(codec);
96 }
97 #endif
98
99 unsigned avcodec_get_edge_width(void)
100 {
101     return EDGE_WIDTH;
102 }
103
104 void avcodec_set_dimensions(AVCodecContext *s, int width, int height){
105     s->coded_width = width;
106     s->coded_height= height;
107     s->width = -((-width )>>s->lowres);
108     s->height= -((-height)>>s->lowres);
109 }
110
111 typedef struct InternalBuffer{
112     int last_pic_num;
113     uint8_t *base[4];
114     uint8_t *data[4];
115     int linesize[4];
116     int width, height;
117     enum PixelFormat pix_fmt;
118 }InternalBuffer;
119
120 #define INTERNAL_BUFFER_SIZE 32
121
122 void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height, int linesize_align[4]){
123     int w_align= 1;
124     int h_align= 1;
125
126     switch(s->pix_fmt){
127     case PIX_FMT_YUV420P:
128     case PIX_FMT_YUYV422:
129     case PIX_FMT_UYVY422:
130     case PIX_FMT_YUV422P:
131     case PIX_FMT_YUV440P:
132     case PIX_FMT_YUV444P:
133     case PIX_FMT_GRAY8:
134     case PIX_FMT_GRAY16BE:
135     case PIX_FMT_GRAY16LE:
136     case PIX_FMT_YUVJ420P:
137     case PIX_FMT_YUVJ422P:
138     case PIX_FMT_YUVJ440P:
139     case PIX_FMT_YUVJ444P:
140     case PIX_FMT_YUVA420P:
141         w_align= 16; //FIXME check for non mpeg style codecs and use less alignment
142         h_align= 16;
143         if(s->codec_id == CODEC_ID_MPEG2VIDEO || s->codec_id == CODEC_ID_MJPEG || s->codec_id == CODEC_ID_AMV || s->codec_id == CODEC_ID_THP)
144             h_align= 32; // interlaced is rounded up to 2 MBs
145         break;
146     case PIX_FMT_YUV411P:
147     case PIX_FMT_UYYVYY411:
148         w_align=32;
149         h_align=8;
150         break;
151     case PIX_FMT_YUV410P:
152         if(s->codec_id == CODEC_ID_SVQ1){
153             w_align=64;
154             h_align=64;
155         }
156     case PIX_FMT_RGB555:
157         if(s->codec_id == CODEC_ID_RPZA){
158             w_align=4;
159             h_align=4;
160         }
161     case PIX_FMT_PAL8:
162     case PIX_FMT_BGR8:
163     case PIX_FMT_RGB8:
164         if(s->codec_id == CODEC_ID_SMC){
165             w_align=4;
166             h_align=4;
167         }
168         break;
169     case PIX_FMT_BGR24:
170         if((s->codec_id == CODEC_ID_MSZH) || (s->codec_id == CODEC_ID_ZLIB)){
171             w_align=4;
172             h_align=4;
173         }
174         break;
175     default:
176         w_align= 1;
177         h_align= 1;
178         break;
179     }
180
181     *width = FFALIGN(*width , w_align);
182     *height= FFALIGN(*height, h_align);
183     if(s->codec_id == CODEC_ID_H264)
184         *height+=2; // some of the optimized chroma MC reads one line too much
185
186     linesize_align[0] =
187     linesize_align[1] =
188     linesize_align[2] =
189     linesize_align[3] = STRIDE_ALIGN;
190 //STRIDE_ALIGN is 8 for SSE* but this does not work for SVQ1 chroma planes
191 //we could change STRIDE_ALIGN to 16 for x86/sse but it would increase the
192 //picture size unneccessarily in some cases. The solution here is not
193 //pretty and better ideas are welcome!
194 #if HAVE_MMX
195     if(s->codec_id == CODEC_ID_SVQ1 || s->codec_id == CODEC_ID_VP5 ||
196        s->codec_id == CODEC_ID_VP6 || s->codec_id == CODEC_ID_VP6F ||
197        s->codec_id == CODEC_ID_VP6A) {
198         linesize_align[0] =
199         linesize_align[1] =
200         linesize_align[2] = 16;
201     }
202 #endif
203 }
204
205 void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height){
206     int chroma_shift = av_pix_fmt_descriptors[s->pix_fmt].log2_chroma_w;
207     int linesize_align[4];
208     int align;
209     avcodec_align_dimensions2(s, width, height, linesize_align);
210     align = FFMAX(linesize_align[0], linesize_align[3]);
211     linesize_align[1] <<= chroma_shift;
212     linesize_align[2] <<= chroma_shift;
213     align = FFMAX3(align, linesize_align[1], linesize_align[2]);
214     *width=FFALIGN(*width, align);
215 }
216
217 #if LIBAVCODEC_VERSION_MAJOR < 53
218 int avcodec_check_dimensions(void *av_log_ctx, unsigned int w, unsigned int h){
219     return av_image_check_size(w, h, 0, av_log_ctx);
220 }
221 #endif
222
223 int avcodec_default_get_buffer(AVCodecContext *s, AVFrame *pic){
224     int i;
225     int w= s->width;
226     int h= s->height;
227     InternalBuffer *buf;
228     int *picture_number;
229
230     if(pic->data[0]!=NULL) {
231         av_log(s, AV_LOG_ERROR, "pic->data[0]!=NULL in avcodec_default_get_buffer\n");
232         return -1;
233     }
234     if(s->internal_buffer_count >= INTERNAL_BUFFER_SIZE) {
235         av_log(s, AV_LOG_ERROR, "internal_buffer_count overflow (missing release_buffer?)\n");
236         return -1;
237     }
238
239     if(av_image_check_size(w, h, 0, s))
240         return -1;
241
242     if(s->internal_buffer==NULL){
243         s->internal_buffer= av_mallocz((INTERNAL_BUFFER_SIZE+1)*sizeof(InternalBuffer));
244     }
245 #if 0
246     s->internal_buffer= av_fast_realloc(
247         s->internal_buffer,
248         &s->internal_buffer_size,
249         sizeof(InternalBuffer)*FFMAX(99,  s->internal_buffer_count+1)/*FIXME*/
250         );
251 #endif
252
253     buf= &((InternalBuffer*)s->internal_buffer)[s->internal_buffer_count];
254     picture_number= &(((InternalBuffer*)s->internal_buffer)[INTERNAL_BUFFER_SIZE]).last_pic_num; //FIXME ugly hack
255     (*picture_number)++;
256
257     if(buf->base[0] && (buf->width != w || buf->height != h || buf->pix_fmt != s->pix_fmt)){
258         for(i=0; i<4; i++){
259             av_freep(&buf->base[i]);
260             buf->data[i]= NULL;
261         }
262     }
263
264     if(buf->base[0]){
265         pic->age= *picture_number - buf->last_pic_num;
266         buf->last_pic_num= *picture_number;
267     }else{
268         int h_chroma_shift, v_chroma_shift;
269         int size[4] = {0};
270         int tmpsize;
271         int unaligned;
272         AVPicture picture;
273         int stride_align[4];
274
275         avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);
276
277         avcodec_align_dimensions2(s, &w, &h, stride_align);
278
279         if(!(s->flags&CODEC_FLAG_EMU_EDGE)){
280             w+= EDGE_WIDTH*2;
281             h+= EDGE_WIDTH*2;
282         }
283
284         do {
285             // NOTE: do not align linesizes individually, this breaks e.g. assumptions
286             // that linesize[0] == 2*linesize[1] in the MPEG-encoder for 4:2:2
287             av_image_fill_linesizes(picture.linesize, s->pix_fmt, w);
288             // increase alignment of w for next try (rhs gives the lowest bit set in w)
289             w += w & ~(w-1);
290
291             unaligned = 0;
292             for (i=0; i<4; i++){
293                 unaligned |= picture.linesize[i] % stride_align[i];
294             }
295         } while (unaligned);
296
297         tmpsize = av_image_fill_pointers(picture.data, s->pix_fmt, h, NULL, picture.linesize);
298         if (tmpsize < 0)
299             return -1;
300
301         for (i=0; i<3 && picture.data[i+1]; i++)
302             size[i] = picture.data[i+1] - picture.data[i];
303         size[i] = tmpsize - (picture.data[i] - picture.data[0]);
304
305         buf->last_pic_num= -256*256*256*64;
306         memset(buf->base, 0, sizeof(buf->base));
307         memset(buf->data, 0, sizeof(buf->data));
308
309         for(i=0; i<4 && size[i]; i++){
310             const int h_shift= i==0 ? 0 : h_chroma_shift;
311             const int v_shift= i==0 ? 0 : v_chroma_shift;
312
313             buf->linesize[i]= picture.linesize[i];
314
315             buf->base[i]= av_malloc(size[i]+16); //FIXME 16
316             if(buf->base[i]==NULL) return -1;
317             memset(buf->base[i], 128, size[i]);
318
319             // no edge if EDGE EMU or not planar YUV
320             if((s->flags&CODEC_FLAG_EMU_EDGE) || !size[2])
321                 buf->data[i] = buf->base[i];
322             else
323                 buf->data[i] = buf->base[i] + FFALIGN((buf->linesize[i]*EDGE_WIDTH>>v_shift) + (EDGE_WIDTH>>h_shift), stride_align[i]);
324         }
325         if(size[1] && !size[2])
326             ff_set_systematic_pal((uint32_t*)buf->data[1], s->pix_fmt);
327         buf->width  = s->width;
328         buf->height = s->height;
329         buf->pix_fmt= s->pix_fmt;
330         pic->age= 256*256*256*64;
331     }
332     pic->type= FF_BUFFER_TYPE_INTERNAL;
333
334     for(i=0; i<4; i++){
335         pic->base[i]= buf->base[i];
336         pic->data[i]= buf->data[i];
337         pic->linesize[i]= buf->linesize[i];
338     }
339     s->internal_buffer_count++;
340
341     pic->reordered_opaque= s->reordered_opaque;
342
343     if(s->debug&FF_DEBUG_BUFFERS)
344         av_log(s, AV_LOG_DEBUG, "default_get_buffer called on pic %p, %d buffers used\n", pic, s->internal_buffer_count);
345
346     return 0;
347 }
348
349 void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic){
350     int i;
351     InternalBuffer *buf, *last;
352
353     assert(pic->type==FF_BUFFER_TYPE_INTERNAL);
354     assert(s->internal_buffer_count);
355
356     buf = NULL; /* avoids warning */
357     for(i=0; i<s->internal_buffer_count; i++){ //just 3-5 checks so is not worth to optimize
358         buf= &((InternalBuffer*)s->internal_buffer)[i];
359         if(buf->data[0] == pic->data[0])
360             break;
361     }
362     assert(i < s->internal_buffer_count);
363     s->internal_buffer_count--;
364     last = &((InternalBuffer*)s->internal_buffer)[s->internal_buffer_count];
365
366     FFSWAP(InternalBuffer, *buf, *last);
367
368     for(i=0; i<4; i++){
369         pic->data[i]=NULL;
370 //        pic->base[i]=NULL;
371     }
372 //printf("R%X\n", pic->opaque);
373
374     if(s->debug&FF_DEBUG_BUFFERS)
375         av_log(s, AV_LOG_DEBUG, "default_release_buffer called on pic %p, %d buffers used\n", pic, s->internal_buffer_count);
376 }
377
378 int avcodec_default_reget_buffer(AVCodecContext *s, AVFrame *pic){
379     AVFrame temp_pic;
380     int i;
381
382     /* If no picture return a new buffer */
383     if(pic->data[0] == NULL) {
384         /* We will copy from buffer, so must be readable */
385         pic->buffer_hints |= FF_BUFFER_HINTS_READABLE;
386         return s->get_buffer(s, pic);
387     }
388
389     /* If internal buffer type return the same buffer */
390     if(pic->type == FF_BUFFER_TYPE_INTERNAL) {
391         pic->reordered_opaque= s->reordered_opaque;
392         return 0;
393     }
394
395     /*
396      * Not internal type and reget_buffer not overridden, emulate cr buffer
397      */
398     temp_pic = *pic;
399     for(i = 0; i < 4; i++)
400         pic->data[i] = pic->base[i] = NULL;
401     pic->opaque = NULL;
402     /* Allocate new frame */
403     if (s->get_buffer(s, pic))
404         return -1;
405     /* Copy image data from old buffer to new buffer */
406     av_picture_copy((AVPicture*)pic, (AVPicture*)&temp_pic, s->pix_fmt, s->width,
407              s->height);
408     s->release_buffer(s, &temp_pic); // Release old frame
409     return 0;
410 }
411
412 int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2),void *arg, int *ret, int count, int size){
413     int i;
414
415     for(i=0; i<count; i++){
416         int r= func(c, (char*)arg + i*size);
417         if(ret) ret[i]= r;
418     }
419     return 0;
420 }
421
422 int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int jobnr, int threadnr),void *arg, int *ret, int count){
423     int i;
424
425     for(i=0; i<count; i++){
426         int r= func(c, arg, i, 0);
427         if(ret) ret[i]= r;
428     }
429     return 0;
430 }
431
432 enum PixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum PixelFormat *fmt){
433     while (*fmt != PIX_FMT_NONE && ff_is_hwaccel_pix_fmt(*fmt))
434         ++fmt;
435     return fmt[0];
436 }
437
438 void avcodec_get_frame_defaults(AVFrame *pic){
439     memset(pic, 0, sizeof(AVFrame));
440
441     pic->pts= AV_NOPTS_VALUE;
442     pic->key_frame= 1;
443 }
444
445 AVFrame *avcodec_alloc_frame(void){
446     AVFrame *pic= av_malloc(sizeof(AVFrame));
447
448     if(pic==NULL) return NULL;
449
450     avcodec_get_frame_defaults(pic);
451
452     return pic;
453 }
454
455 int attribute_align_arg avcodec_open(AVCodecContext *avctx, AVCodec *codec)
456 {
457     int ret= -1;
458
459     /* If there is a user-supplied mutex locking routine, call it. */
460     if (ff_lockmgr_cb) {
461         if ((*ff_lockmgr_cb)(&codec_mutex, AV_LOCK_OBTAIN))
462             return -1;
463     }
464
465     entangled_thread_counter++;
466     if(entangled_thread_counter != 1){
467         av_log(avctx, AV_LOG_ERROR, "insufficient thread locking around avcodec_open/close()\n");
468         goto end;
469     }
470
471     if(avctx->codec || !codec)
472         goto end;
473
474     if (codec->priv_data_size > 0) {
475       if(!avctx->priv_data){
476         avctx->priv_data = av_mallocz(codec->priv_data_size);
477         if (!avctx->priv_data) {
478             ret = AVERROR(ENOMEM);
479             goto end;
480         }
481         if(codec->priv_class){ //this can be droped once all user apps use   avcodec_get_context_defaults3()
482             *(AVClass**)avctx->priv_data= codec->priv_class;
483             av_opt_set_defaults(avctx->priv_data);
484         }
485       }
486     } else {
487         avctx->priv_data = NULL;
488     }
489
490     if(avctx->coded_width && avctx->coded_height)
491         avcodec_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);
492     else if(avctx->width && avctx->height)
493         avcodec_set_dimensions(avctx, avctx->width, avctx->height);
494
495     if ((avctx->coded_width || avctx->coded_height || avctx->width || avctx->height)
496         && (  av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx) < 0
497            || av_image_check_size(avctx->width,       avctx->height,       0, avctx) < 0)) {
498         av_log(avctx, AV_LOG_WARNING, "ignoring invalid width/height values\n");
499         avcodec_set_dimensions(avctx, 0, 0);
500     }
501
502 #define SANE_NB_CHANNELS 128U
503     if (avctx->channels > SANE_NB_CHANNELS) {
504         ret = AVERROR(EINVAL);
505         goto free_and_end;
506     }
507
508     avctx->codec = codec;
509     if ((avctx->codec_type == AVMEDIA_TYPE_UNKNOWN || avctx->codec_type == codec->type) &&
510         avctx->codec_id == CODEC_ID_NONE) {
511         avctx->codec_type = codec->type;
512         avctx->codec_id   = codec->id;
513     }
514     if(avctx->codec_id != codec->id || avctx->codec_type != codec->type){
515         av_log(avctx, AV_LOG_ERROR, "codec type or id mismatches\n");
516         goto free_and_end;
517     }
518     avctx->frame_number = 0;
519     if (avctx->codec->max_lowres < avctx->lowres) {
520         av_log(avctx, AV_LOG_ERROR, "The maximum value for lowres supported by the decoder is %d\n",
521                avctx->codec->max_lowres);
522         goto free_and_end;
523     }
524
525     if(avctx->codec->init){
526         ret = avctx->codec->init(avctx);
527         if (ret < 0) {
528             goto free_and_end;
529         }
530     }
531     ret=0;
532 end:
533     entangled_thread_counter--;
534
535     /* Release any user-supplied mutex. */
536     if (ff_lockmgr_cb) {
537         (*ff_lockmgr_cb)(&codec_mutex, AV_LOCK_RELEASE);
538     }
539     return ret;
540 free_and_end:
541     av_freep(&avctx->priv_data);
542     avctx->codec= NULL;
543     goto end;
544 }
545
546 int attribute_align_arg avcodec_encode_audio(AVCodecContext *avctx, uint8_t *buf, int buf_size,
547                          const short *samples)
548 {
549     if(buf_size < FF_MIN_BUFFER_SIZE && 0){
550         av_log(avctx, AV_LOG_ERROR, "buffer smaller than minimum size\n");
551         return -1;
552     }
553     if((avctx->codec->capabilities & CODEC_CAP_DELAY) || samples){
554         int ret = avctx->codec->encode(avctx, buf, buf_size, samples);
555         avctx->frame_number++;
556         return ret;
557     }else
558         return 0;
559 }
560
561 int attribute_align_arg avcodec_encode_video(AVCodecContext *avctx, uint8_t *buf, int buf_size,
562                          const AVFrame *pict)
563 {
564     if(buf_size < FF_MIN_BUFFER_SIZE){
565         av_log(avctx, AV_LOG_ERROR, "buffer smaller than minimum size\n");
566         return -1;
567     }
568     if(av_image_check_size(avctx->width, avctx->height, 0, avctx))
569         return -1;
570     if((avctx->codec->capabilities & CODEC_CAP_DELAY) || pict){
571         int ret = avctx->codec->encode(avctx, buf, buf_size, pict);
572         avctx->frame_number++;
573         emms_c(); //needed to avoid an emms_c() call before every return;
574
575         return ret;
576     }else
577         return 0;
578 }
579
580 int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size,
581                             const AVSubtitle *sub)
582 {
583     int ret;
584     if(sub->start_display_time) {
585         av_log(avctx, AV_LOG_ERROR, "start_display_time must be 0.\n");
586         return -1;
587     }
588     if(sub->num_rects == 0 || !sub->rects)
589         return -1;
590     ret = avctx->codec->encode(avctx, buf, buf_size, sub);
591     avctx->frame_number++;
592     return ret;
593 }
594
595 #if FF_API_VIDEO_OLD
596 int attribute_align_arg avcodec_decode_video(AVCodecContext *avctx, AVFrame *picture,
597                          int *got_picture_ptr,
598                          const uint8_t *buf, int buf_size)
599 {
600     AVPacket avpkt;
601     av_init_packet(&avpkt);
602     avpkt.data = buf;
603     avpkt.size = buf_size;
604     // HACK for CorePNG to decode as normal PNG by default
605     avpkt.flags = AV_PKT_FLAG_KEY;
606
607     return avcodec_decode_video2(avctx, picture, got_picture_ptr, &avpkt);
608 }
609 #endif
610
611 int attribute_align_arg avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
612                          int *got_picture_ptr,
613                          AVPacket *avpkt)
614 {
615     int ret;
616
617     *got_picture_ptr= 0;
618     if((avctx->coded_width||avctx->coded_height) && av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx))
619         return -1;
620     if((avctx->codec->capabilities & CODEC_CAP_DELAY) || avpkt->size){
621         ret = avctx->codec->decode(avctx, picture, got_picture_ptr,
622                                 avpkt);
623
624         emms_c(); //needed to avoid an emms_c() call before every return;
625
626         if (*got_picture_ptr)
627             avctx->frame_number++;
628     }else
629         ret= 0;
630
631     return ret;
632 }
633
634 #if FF_API_AUDIO_OLD
635 int attribute_align_arg avcodec_decode_audio2(AVCodecContext *avctx, int16_t *samples,
636                          int *frame_size_ptr,
637                          const uint8_t *buf, int buf_size)
638 {
639     AVPacket avpkt;
640     av_init_packet(&avpkt);
641     avpkt.data = buf;
642     avpkt.size = buf_size;
643
644     return avcodec_decode_audio3(avctx, samples, frame_size_ptr, &avpkt);
645 }
646 #endif
647
648 int attribute_align_arg avcodec_decode_audio3(AVCodecContext *avctx, int16_t *samples,
649                          int *frame_size_ptr,
650                          AVPacket *avpkt)
651 {
652     int ret;
653
654     if((avctx->codec->capabilities & CODEC_CAP_DELAY) || avpkt->size){
655         //FIXME remove the check below _after_ ensuring that all audio check that the available space is enough
656         if(*frame_size_ptr < AVCODEC_MAX_AUDIO_FRAME_SIZE){
657             av_log(avctx, AV_LOG_ERROR, "buffer smaller than AVCODEC_MAX_AUDIO_FRAME_SIZE\n");
658             return -1;
659         }
660         if(*frame_size_ptr < FF_MIN_BUFFER_SIZE ||
661         *frame_size_ptr < avctx->channels * avctx->frame_size * sizeof(int16_t)){
662             av_log(avctx, AV_LOG_ERROR, "buffer %d too small\n", *frame_size_ptr);
663             return -1;
664         }
665
666         ret = avctx->codec->decode(avctx, samples, frame_size_ptr, avpkt);
667         avctx->frame_number++;
668     }else{
669         ret= 0;
670         *frame_size_ptr=0;
671     }
672     return ret;
673 }
674
675 #if FF_API_SUBTITLE_OLD
676 int avcodec_decode_subtitle(AVCodecContext *avctx, AVSubtitle *sub,
677                             int *got_sub_ptr,
678                             const uint8_t *buf, int buf_size)
679 {
680     AVPacket avpkt;
681     av_init_packet(&avpkt);
682     avpkt.data = buf;
683     avpkt.size = buf_size;
684
685     return avcodec_decode_subtitle2(avctx, sub, got_sub_ptr, &avpkt);
686 }
687 #endif
688
689 int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub,
690                             int *got_sub_ptr,
691                             AVPacket *avpkt)
692 {
693     int ret;
694
695     *got_sub_ptr = 0;
696     ret = avctx->codec->decode(avctx, sub, got_sub_ptr, avpkt);
697     if (*got_sub_ptr)
698         avctx->frame_number++;
699     return ret;
700 }
701
702 void avsubtitle_free(AVSubtitle *sub)
703 {
704     int i;
705
706     for (i = 0; i < sub->num_rects; i++)
707     {
708         av_freep(&sub->rects[i]->pict.data[0]);
709         av_freep(&sub->rects[i]->pict.data[1]);
710         av_freep(&sub->rects[i]->pict.data[2]);
711         av_freep(&sub->rects[i]->pict.data[3]);
712         av_freep(&sub->rects[i]->text);
713         av_freep(&sub->rects[i]->ass);
714         av_freep(&sub->rects[i]);
715     }
716
717     av_freep(&sub->rects);
718
719     memset(sub, 0, sizeof(AVSubtitle));
720 }
721
722 av_cold int avcodec_close(AVCodecContext *avctx)
723 {
724     /* If there is a user-supplied mutex locking routine, call it. */
725     if (ff_lockmgr_cb) {
726         if ((*ff_lockmgr_cb)(&codec_mutex, AV_LOCK_OBTAIN))
727             return -1;
728     }
729
730     entangled_thread_counter++;
731     if(entangled_thread_counter != 1){
732         av_log(avctx, AV_LOG_ERROR, "insufficient thread locking around avcodec_open/close()\n");
733         entangled_thread_counter--;
734         return -1;
735     }
736
737     if (HAVE_THREADS && avctx->thread_opaque)
738         avcodec_thread_free(avctx);
739     if (avctx->codec && avctx->codec->close)
740         avctx->codec->close(avctx);
741     avcodec_default_free_buffers(avctx);
742     avctx->coded_frame = NULL;
743     av_freep(&avctx->priv_data);
744     if(avctx->codec && avctx->codec->encode)
745         av_freep(&avctx->extradata);
746     avctx->codec = NULL;
747     entangled_thread_counter--;
748
749     /* Release any user-supplied mutex. */
750     if (ff_lockmgr_cb) {
751         (*ff_lockmgr_cb)(&codec_mutex, AV_LOCK_RELEASE);
752     }
753     return 0;
754 }
755
756 AVCodec *avcodec_find_encoder(enum CodecID id)
757 {
758     AVCodec *p, *experimental=NULL;
759     p = first_avcodec;
760     while (p) {
761         if (p->encode != NULL && p->id == id) {
762             if (p->capabilities & CODEC_CAP_EXPERIMENTAL && !experimental) {
763                 experimental = p;
764             } else
765                 return p;
766         }
767         p = p->next;
768     }
769     return experimental;
770 }
771
772 AVCodec *avcodec_find_encoder_by_name(const char *name)
773 {
774     AVCodec *p;
775     if (!name)
776         return NULL;
777     p = first_avcodec;
778     while (p) {
779         if (p->encode != NULL && strcmp(name,p->name) == 0)
780             return p;
781         p = p->next;
782     }
783     return NULL;
784 }
785
786 AVCodec *avcodec_find_decoder(enum CodecID id)
787 {
788     AVCodec *p;
789     p = first_avcodec;
790     while (p) {
791         if (p->decode != NULL && p->id == id)
792             return p;
793         p = p->next;
794     }
795     return NULL;
796 }
797
798 AVCodec *avcodec_find_decoder_by_name(const char *name)
799 {
800     AVCodec *p;
801     if (!name)
802         return NULL;
803     p = first_avcodec;
804     while (p) {
805         if (p->decode != NULL && strcmp(name,p->name) == 0)
806             return p;
807         p = p->next;
808     }
809     return NULL;
810 }
811
812 static int get_bit_rate(AVCodecContext *ctx)
813 {
814     int bit_rate;
815     int bits_per_sample;
816
817     switch(ctx->codec_type) {
818     case AVMEDIA_TYPE_VIDEO:
819     case AVMEDIA_TYPE_DATA:
820     case AVMEDIA_TYPE_SUBTITLE:
821     case AVMEDIA_TYPE_ATTACHMENT:
822         bit_rate = ctx->bit_rate;
823         break;
824     case AVMEDIA_TYPE_AUDIO:
825         bits_per_sample = av_get_bits_per_sample(ctx->codec_id);
826         bit_rate = bits_per_sample ? ctx->sample_rate * ctx->channels * bits_per_sample : ctx->bit_rate;
827         break;
828     default:
829         bit_rate = 0;
830         break;
831     }
832     return bit_rate;
833 }
834
835 size_t av_get_codec_tag_string(char *buf, size_t buf_size, unsigned int codec_tag)
836 {
837     int i, len, ret = 0;
838
839     for (i = 0; i < 4; i++) {
840         len = snprintf(buf, buf_size,
841                        isprint(codec_tag&0xFF) ? "%c" : "[%d]", codec_tag&0xFF);
842         buf      += len;
843         buf_size  = buf_size > len ? buf_size - len : 0;
844         ret      += len;
845         codec_tag>>=8;
846     }
847     return ret;
848 }
849
850 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
851 {
852     const char *codec_name;
853     AVCodec *p;
854     char buf1[32];
855     int bitrate;
856     AVRational display_aspect_ratio;
857
858     if (encode)
859         p = avcodec_find_encoder(enc->codec_id);
860     else
861         p = avcodec_find_decoder(enc->codec_id);
862
863     if (p) {
864         codec_name = p->name;
865     } else if (enc->codec_id == CODEC_ID_MPEG2TS) {
866         /* fake mpeg2 transport stream codec (currently not
867            registered) */
868         codec_name = "mpeg2ts";
869     } else if (enc->codec_name[0] != '\0') {
870         codec_name = enc->codec_name;
871     } else {
872         /* output avi tags */
873         char tag_buf[32];
874         av_get_codec_tag_string(tag_buf, sizeof(tag_buf), enc->codec_tag);
875         snprintf(buf1, sizeof(buf1), "%s / 0x%04X", tag_buf, enc->codec_tag);
876         codec_name = buf1;
877     }
878
879     switch(enc->codec_type) {
880     case AVMEDIA_TYPE_VIDEO:
881         snprintf(buf, buf_size,
882                  "Video: %s%s",
883                  codec_name, enc->mb_decision ? " (hq)" : "");
884         if (enc->pix_fmt != PIX_FMT_NONE) {
885             snprintf(buf + strlen(buf), buf_size - strlen(buf),
886                      ", %s",
887                      avcodec_get_pix_fmt_name(enc->pix_fmt));
888         }
889         if (enc->width) {
890             snprintf(buf + strlen(buf), buf_size - strlen(buf),
891                      ", %dx%d",
892                      enc->width, enc->height);
893             if (enc->sample_aspect_ratio.num) {
894                 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
895                           enc->width*enc->sample_aspect_ratio.num,
896                           enc->height*enc->sample_aspect_ratio.den,
897                           1024*1024);
898                 snprintf(buf + strlen(buf), buf_size - strlen(buf),
899                          " [PAR %d:%d DAR %d:%d]",
900                          enc->sample_aspect_ratio.num, enc->sample_aspect_ratio.den,
901                          display_aspect_ratio.num, display_aspect_ratio.den);
902             }
903             if(av_log_get_level() >= AV_LOG_DEBUG){
904                 int g= av_gcd(enc->time_base.num, enc->time_base.den);
905                 snprintf(buf + strlen(buf), buf_size - strlen(buf),
906                      ", %d/%d",
907                      enc->time_base.num/g, enc->time_base.den/g);
908             }
909         }
910         if (encode) {
911             snprintf(buf + strlen(buf), buf_size - strlen(buf),
912                      ", q=%d-%d", enc->qmin, enc->qmax);
913         }
914         break;
915     case AVMEDIA_TYPE_AUDIO:
916         snprintf(buf, buf_size,
917                  "Audio: %s",
918                  codec_name);
919         if (enc->sample_rate) {
920             snprintf(buf + strlen(buf), buf_size - strlen(buf),
921                      ", %d Hz", enc->sample_rate);
922         }
923         av_strlcat(buf, ", ", buf_size);
924         avcodec_get_channel_layout_string(buf + strlen(buf), buf_size - strlen(buf), enc->channels, enc->channel_layout);
925         if (enc->sample_fmt != SAMPLE_FMT_NONE) {
926             snprintf(buf + strlen(buf), buf_size - strlen(buf),
927                      ", %s", av_get_sample_fmt_name(enc->sample_fmt));
928         }
929         break;
930     case AVMEDIA_TYPE_DATA:
931         snprintf(buf, buf_size, "Data: %s", codec_name);
932         break;
933     case AVMEDIA_TYPE_SUBTITLE:
934         snprintf(buf, buf_size, "Subtitle: %s", codec_name);
935         break;
936     case AVMEDIA_TYPE_ATTACHMENT:
937         snprintf(buf, buf_size, "Attachment: %s", codec_name);
938         break;
939     default:
940         snprintf(buf, buf_size, "Invalid Codec type %d", enc->codec_type);
941         return;
942     }
943     if (encode) {
944         if (enc->flags & CODEC_FLAG_PASS1)
945             snprintf(buf + strlen(buf), buf_size - strlen(buf),
946                      ", pass 1");
947         if (enc->flags & CODEC_FLAG_PASS2)
948             snprintf(buf + strlen(buf), buf_size - strlen(buf),
949                      ", pass 2");
950     }
951     bitrate = get_bit_rate(enc);
952     if (bitrate != 0) {
953         snprintf(buf + strlen(buf), buf_size - strlen(buf),
954                  ", %d kb/s", bitrate / 1000);
955     }
956 }
957
958 unsigned avcodec_version( void )
959 {
960   return LIBAVCODEC_VERSION_INT;
961 }
962
963 const char *avcodec_configuration(void)
964 {
965     return FFMPEG_CONFIGURATION;
966 }
967
968 const char *avcodec_license(void)
969 {
970 #define LICENSE_PREFIX "libavcodec license: "
971     return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
972 }
973
974 void avcodec_init(void)
975 {
976     static int initialized = 0;
977
978     if (initialized != 0)
979         return;
980     initialized = 1;
981
982     dsputil_static_init();
983 }
984
985 void avcodec_flush_buffers(AVCodecContext *avctx)
986 {
987     if(avctx->codec->flush)
988         avctx->codec->flush(avctx);
989 }
990
991 void avcodec_default_free_buffers(AVCodecContext *s){
992     int i, j;
993
994     if(s->internal_buffer==NULL) return;
995
996     if (s->internal_buffer_count)
997         av_log(s, AV_LOG_WARNING, "Found %i unreleased buffers!\n", s->internal_buffer_count);
998     for(i=0; i<INTERNAL_BUFFER_SIZE; i++){
999         InternalBuffer *buf= &((InternalBuffer*)s->internal_buffer)[i];
1000         for(j=0; j<4; j++){
1001             av_freep(&buf->base[j]);
1002             buf->data[j]= NULL;
1003         }
1004     }
1005     av_freep(&s->internal_buffer);
1006
1007     s->internal_buffer_count=0;
1008 }
1009
1010 char av_get_pict_type_char(int pict_type){
1011     switch(pict_type){
1012     case FF_I_TYPE: return 'I';
1013     case FF_P_TYPE: return 'P';
1014     case FF_B_TYPE: return 'B';
1015     case FF_S_TYPE: return 'S';
1016     case FF_SI_TYPE:return 'i';
1017     case FF_SP_TYPE:return 'p';
1018     case FF_BI_TYPE:return 'b';
1019     default:        return '?';
1020     }
1021 }
1022
1023 int av_get_bits_per_sample(enum CodecID codec_id){
1024     switch(codec_id){
1025     case CODEC_ID_ADPCM_SBPRO_2:
1026         return 2;
1027     case CODEC_ID_ADPCM_SBPRO_3:
1028         return 3;
1029     case CODEC_ID_ADPCM_SBPRO_4:
1030     case CODEC_ID_ADPCM_CT:
1031     case CODEC_ID_ADPCM_IMA_WAV:
1032     case CODEC_ID_ADPCM_MS:
1033     case CODEC_ID_ADPCM_YAMAHA:
1034         return 4;
1035     case CODEC_ID_PCM_ALAW:
1036     case CODEC_ID_PCM_MULAW:
1037     case CODEC_ID_PCM_S8:
1038     case CODEC_ID_PCM_U8:
1039     case CODEC_ID_PCM_ZORK:
1040         return 8;
1041     case CODEC_ID_PCM_S16BE:
1042     case CODEC_ID_PCM_S16LE:
1043     case CODEC_ID_PCM_S16LE_PLANAR:
1044     case CODEC_ID_PCM_U16BE:
1045     case CODEC_ID_PCM_U16LE:
1046         return 16;
1047     case CODEC_ID_PCM_S24DAUD:
1048     case CODEC_ID_PCM_S24BE:
1049     case CODEC_ID_PCM_S24LE:
1050     case CODEC_ID_PCM_U24BE:
1051     case CODEC_ID_PCM_U24LE:
1052         return 24;
1053     case CODEC_ID_PCM_S32BE:
1054     case CODEC_ID_PCM_S32LE:
1055     case CODEC_ID_PCM_U32BE:
1056     case CODEC_ID_PCM_U32LE:
1057     case CODEC_ID_PCM_F32BE:
1058     case CODEC_ID_PCM_F32LE:
1059         return 32;
1060     case CODEC_ID_PCM_F64BE:
1061     case CODEC_ID_PCM_F64LE:
1062         return 64;
1063     default:
1064         return 0;
1065     }
1066 }
1067
1068 #if FF_API_OLD_SAMPLE_FMT
1069 int av_get_bits_per_sample_format(enum SampleFormat sample_fmt) {
1070     return av_get_bits_per_sample_fmt(sample_fmt);
1071 }
1072 #endif
1073
1074 #if !HAVE_THREADS
1075 int avcodec_thread_init(AVCodecContext *s, int thread_count){
1076     s->thread_count = thread_count;
1077     return -1;
1078 }
1079 #endif
1080
1081 unsigned int av_xiphlacing(unsigned char *s, unsigned int v)
1082 {
1083     unsigned int n = 0;
1084
1085     while(v >= 0xff) {
1086         *s++ = 0xff;
1087         v -= 0xff;
1088         n++;
1089     }
1090     *s = v;
1091     n++;
1092     return n;
1093 }
1094
1095 #if LIBAVCODEC_VERSION_MAJOR < 53
1096 #include "libavcore/parseutils.h"
1097
1098 int av_parse_video_frame_size(int *width_ptr, int *height_ptr, const char *str)
1099 {
1100     return av_parse_video_size(width_ptr, height_ptr, str);
1101 }
1102
1103 int av_parse_video_frame_rate(AVRational *frame_rate, const char *arg)
1104 {
1105     return av_parse_video_rate(frame_rate, arg);
1106 }
1107 #endif
1108
1109 int ff_match_2uint16(const uint16_t (*tab)[2], int size, int a, int b){
1110     int i;
1111     for(i=0; i<size && !(tab[i][0]==a && tab[i][1]==b); i++);
1112     return i;
1113 }
1114
1115 void av_log_missing_feature(void *avc, const char *feature, int want_sample)
1116 {
1117     av_log(avc, AV_LOG_WARNING, "%s not implemented. Update your FFmpeg "
1118             "version to the newest one from SVN. If the problem still "
1119             "occurs, it means that your file has a feature which has not "
1120             "been implemented.", feature);
1121     if(want_sample)
1122         av_log_ask_for_sample(avc, NULL);
1123     else
1124         av_log(avc, AV_LOG_WARNING, "\n");
1125 }
1126
1127 void av_log_ask_for_sample(void *avc, const char *msg)
1128 {
1129     if (msg)
1130         av_log(avc, AV_LOG_WARNING, "%s ", msg);
1131     av_log(avc, AV_LOG_WARNING, "If you want to help, upload a sample "
1132             "of this file to ftp://upload.ffmpeg.org/MPlayer/incoming/ "
1133             "and contact the ffmpeg-devel mailing list.\n");
1134 }
1135
1136 static AVHWAccel *first_hwaccel = NULL;
1137
1138 void av_register_hwaccel(AVHWAccel *hwaccel)
1139 {
1140     AVHWAccel **p = &first_hwaccel;
1141     while (*p)
1142         p = &(*p)->next;
1143     *p = hwaccel;
1144     hwaccel->next = NULL;
1145 }
1146
1147 AVHWAccel *av_hwaccel_next(AVHWAccel *hwaccel)
1148 {
1149     return hwaccel ? hwaccel->next : first_hwaccel;
1150 }
1151
1152 AVHWAccel *ff_find_hwaccel(enum CodecID codec_id, enum PixelFormat pix_fmt)
1153 {
1154     AVHWAccel *hwaccel=NULL;
1155
1156     while((hwaccel= av_hwaccel_next(hwaccel))){
1157         if (   hwaccel->id      == codec_id
1158             && hwaccel->pix_fmt == pix_fmt)
1159             return hwaccel;
1160     }
1161     return NULL;
1162 }
1163
1164 int av_lockmgr_register(int (*cb)(void **mutex, enum AVLockOp op))
1165 {
1166     if (ff_lockmgr_cb) {
1167         if (ff_lockmgr_cb(&codec_mutex, AV_LOCK_DESTROY))
1168             return -1;
1169     }
1170
1171     ff_lockmgr_cb = cb;
1172
1173     if (ff_lockmgr_cb) {
1174         if (ff_lockmgr_cb(&codec_mutex, AV_LOCK_CREATE))
1175             return -1;
1176     }
1177     return 0;
1178 }
1179
1180 unsigned int ff_toupper4(unsigned int x)
1181 {
1182     return     toupper( x     &0xFF)
1183             + (toupper((x>>8 )&0xFF)<<8 )
1184             + (toupper((x>>16)&0xFF)<<16)
1185             + (toupper((x>>24)&0xFF)<<24);
1186 }