AVVideoFrame -> AVFrame
[ffmpeg.git] / libavcodec / utils.c
1 /*
2  * utils for libavcodec
3  * Copyright (c) 2001 Fabrice Bellard.
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18  */
19 #include "avcodec.h"
20 #include "dsputil.h"
21 #include "mpegvideo.h"
22
23 void *av_mallocz(unsigned int size)
24 {
25     void *ptr;
26     
27     if(size == 0) fprintf(stderr, "Warning, allocating 0 bytes\n");
28     
29     ptr = av_malloc(size);
30     if (!ptr)
31         return NULL;
32     memset(ptr, 0, size);
33     return ptr;
34 }
35
36 /* allocation of static arrays - do not use for normal allocation */
37 static unsigned int last_static = 0;
38 static char*** array_static = NULL;
39 static const unsigned int grow_static = 64; // ^2
40 void *__av_mallocz_static(void** location, unsigned int size)
41 {
42     int l = (last_static + grow_static) & ~(grow_static - 1);
43     void *ptr = av_mallocz(size);
44     if (!ptr)
45         return NULL;
46
47     if (location)
48     {
49         if (l > last_static)
50             array_static = realloc(array_static, l);
51         array_static[last_static++] = (char**) location;
52         *location = ptr;
53     }
54     return ptr;
55 }
56 /* free all static arrays and reset pointers to 0 */
57 void av_free_static()
58 {
59     if (array_static)
60     {
61         unsigned i;
62         for (i = 0; i < last_static; i++)
63         {
64             free(*array_static[i]);
65             *array_static[i] = NULL;
66         }
67         free(array_static);
68         array_static = 0;
69     }
70     last_static = 0;
71 }
72
73 /* cannot call it directly because of 'void **' casting is not automatic */
74 void __av_freep(void **ptr)
75 {
76     av_free(*ptr);
77     *ptr = NULL;
78 }
79
80 /* encoder management */
81 AVCodec *first_avcodec;
82
83 void register_avcodec(AVCodec *format)
84 {
85     AVCodec **p;
86     p = &first_avcodec;
87     while (*p != NULL) p = &(*p)->next;
88     *p = format;
89     format->next = NULL;
90 }
91
92 void avcodec_get_chroma_sub_sample(int fmt, int *h_shift, int *v_shift){
93     switch(fmt){
94     case PIX_FMT_YUV410P:
95         *h_shift=2;
96         *v_shift=2;
97         break;
98     case PIX_FMT_YUV420P:
99         *h_shift=1;
100         *v_shift=1;
101         break;
102     case PIX_FMT_YUV411P:
103         *h_shift=2;
104         *v_shift=0;
105         break;
106     case PIX_FMT_YUV422P:
107     case PIX_FMT_YUV422:
108         *h_shift=1;
109         *v_shift=0;
110         break;
111     default: //RGB/...
112         *h_shift=0;
113         *v_shift=0;
114         break;
115     }
116 }
117
118 typedef struct DefaultPicOpaque{
119     int last_pic_num;
120     uint8_t *data[4];
121 }DefaultPicOpaque;
122
123 int avcodec_default_get_buffer(AVCodecContext *s, AVFrame *pic){
124     int i;
125     const int width = s->width;
126     const int height= s->height;
127     DefaultPicOpaque *opaque;
128     
129     assert(pic->data[0]==NULL);
130     assert(pic->type==0 || pic->type==FF_TYPE_INTERNAL);
131
132     if(pic->opaque){
133         opaque= (DefaultPicOpaque *)pic->opaque;
134         for(i=0; i<3; i++)
135             pic->data[i]= opaque->data[i];
136
137 //    printf("get_buffer %X coded_pic_num:%d last:%d\n", pic->opaque, pic->coded_picture_number, opaque->last_pic_num);    
138         pic->age= pic->coded_picture_number - opaque->last_pic_num;
139         opaque->last_pic_num= pic->coded_picture_number;
140 //printf("age: %d %d %d\n", pic->age, c->picture_number, pic->coded_picture_number);
141     }else{
142         int align, h_chroma_shift, v_chroma_shift;
143         int w, h, pixel_size;
144         
145         avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);
146         
147         switch(s->pix_fmt){
148         case PIX_FMT_YUV422:
149             pixel_size=2;
150             break;
151         case PIX_FMT_RGB24:
152         case PIX_FMT_BGR24:
153             pixel_size=3;
154             break;
155         case PIX_FMT_BGRA32:
156         case PIX_FMT_RGBA32:
157             pixel_size=4;
158             break;
159         default:
160             pixel_size=1;
161         }
162         
163         if(s->codec_id==CODEC_ID_SVQ1) align=63;
164         else                           align=15;
165     
166         w= (width +align)&~align;
167         h= (height+align)&~align;
168     
169         if(!(s->flags&CODEC_FLAG_EMU_EDGE)){
170             w+= EDGE_WIDTH*2;
171             h+= EDGE_WIDTH*2;
172         }
173         
174         opaque= av_mallocz(sizeof(DefaultPicOpaque));
175         if(opaque==NULL) return -1;
176
177         pic->opaque= opaque;
178         opaque->last_pic_num= -256*256*256*64;
179
180         for(i=0; i<3; i++){
181             int h_shift= i==0 ? 0 : h_chroma_shift;
182             int v_shift= i==0 ? 0 : v_chroma_shift;
183
184             pic->linesize[i]= pixel_size*w>>h_shift;
185
186             pic->base[i]= av_mallocz((pic->linesize[i]*h>>v_shift)+16); //FIXME 16
187             if(pic->base[i]==NULL) return -1;
188
189             memset(pic->base[i], 128, pic->linesize[i]*h>>v_shift);
190         
191             if(s->flags&CODEC_FLAG_EMU_EDGE)
192                 pic->data[i] = pic->base[i] + 16; //FIXME 16
193             else
194                 pic->data[i] = pic->base[i] + (pic->linesize[i]*EDGE_WIDTH>>v_shift) + (EDGE_WIDTH>>h_shift) + 16; //FIXME 16
195             
196             opaque->data[i]= pic->data[i];
197         }
198         pic->age= 256*256*256*64;
199         pic->type= FF_BUFFER_TYPE_INTERNAL;
200     }
201
202     return 0;
203 }
204
205 void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic){
206     int i;
207     
208     assert(pic->type==FF_BUFFER_TYPE_INTERNAL);
209     
210     for(i=0; i<3; i++)
211         pic->data[i]=NULL;
212 //printf("R%X\n", pic->opaque);
213 }
214
215 void avcodec_get_context_defaults(AVCodecContext *s){
216     s->bit_rate= 800*1000;
217     s->bit_rate_tolerance= s->bit_rate*10;
218     s->qmin= 2;
219     s->qmax= 31;
220     s->rc_eq= "tex^qComp";
221     s->qcompress= 0.5;
222     s->max_qdiff= 3;
223     s->b_quant_factor=1.25;
224     s->b_quant_offset=1.25;
225     s->i_quant_factor=-0.8;
226     s->i_quant_offset=0.0;
227     s->error_concealment= 3;
228     s->error_resilience= 1;
229     s->workaround_bugs= FF_BUG_AUTODETECT;
230     s->frame_rate = 25 * FRAME_RATE_BASE;
231     s->gop_size= 50;
232     s->me_method= ME_EPZS;
233     s->get_buffer= avcodec_default_get_buffer;
234     s->release_buffer= avcodec_default_release_buffer;
235 }
236
237 /**
238  * allocates a AVCodecContext and set it to defaults.
239  * this can be deallocated by simply calling free() 
240  */
241 AVCodecContext *avcodec_alloc_context(void){
242     AVCodecContext *avctx= av_mallocz(sizeof(AVCodecContext));
243     
244     if(avctx==NULL) return NULL;
245     
246     avcodec_get_context_defaults(avctx);
247     
248     return avctx;
249 }
250
251 /**
252  * allocates a AVPFrame and set it to defaults.
253  * this can be deallocated by simply calling free() 
254  */
255 AVFrame *avcodec_alloc_frame(void){
256     AVFrame *pic= av_mallocz(sizeof(AVFrame));
257     
258     return pic;
259 }
260
261 int avcodec_open(AVCodecContext *avctx, AVCodec *codec)
262 {
263     int ret;
264
265     avctx->codec = codec;
266     avctx->frame_number = 0;
267     if (codec->priv_data_size > 0) {
268         avctx->priv_data = av_mallocz(codec->priv_data_size);
269         if (!avctx->priv_data) 
270             return -ENOMEM;
271     } else {
272         avctx->priv_data = NULL;
273     }
274     ret = avctx->codec->init(avctx);
275     if (ret < 0) {
276         av_freep(&avctx->priv_data);
277         return ret;
278     }
279     return 0;
280 }
281
282 int avcodec_encode_audio(AVCodecContext *avctx, UINT8 *buf, int buf_size, 
283                          const short *samples)
284 {
285     int ret;
286
287     ret = avctx->codec->encode(avctx, buf, buf_size, (void *)samples);
288     avctx->frame_number++;
289     return ret;
290 }
291
292 int avcodec_encode_video(AVCodecContext *avctx, UINT8 *buf, int buf_size, 
293                          const AVFrame *pict)
294 {
295     int ret;
296
297     ret = avctx->codec->encode(avctx, buf, buf_size, (void *)pict);
298     
299     emms_c(); //needed to avoid a emms_c() call before every return;
300
301     avctx->frame_number++;
302     return ret;
303 }
304
305 /* decode a frame. return -1 if error, otherwise return the number of
306    bytes used. If no frame could be decompressed, *got_picture_ptr is
307    zero. Otherwise, it is non zero */
308 int avcodec_decode_video(AVCodecContext *avctx, AVFrame *picture, 
309                          int *got_picture_ptr,
310                          UINT8 *buf, int buf_size)
311 {
312     int ret;
313     
314     ret = avctx->codec->decode(avctx, picture, got_picture_ptr, 
315                                buf, buf_size);
316
317     emms_c(); //needed to avoid a emms_c() call before every return;
318     
319     if (*got_picture_ptr)                           
320         avctx->frame_number++;
321     return ret;
322 }
323
324 /* decode an audio frame. return -1 if error, otherwise return the
325    *number of bytes used. If no frame could be decompressed,
326    *frame_size_ptr is zero. Otherwise, it is the decompressed frame
327    *size in BYTES. */
328 int avcodec_decode_audio(AVCodecContext *avctx, INT16 *samples, 
329                          int *frame_size_ptr,
330                          UINT8 *buf, int buf_size)
331 {
332     int ret;
333
334     ret = avctx->codec->decode(avctx, samples, frame_size_ptr, 
335                                buf, buf_size);
336     avctx->frame_number++;
337     return ret;
338 }
339
340 int avcodec_close(AVCodecContext *avctx)
341 {
342     if (avctx->codec->close)
343         avctx->codec->close(avctx);
344     av_freep(&avctx->priv_data);
345     avctx->codec = NULL;
346     return 0;
347 }
348
349 AVCodec *avcodec_find_encoder(enum CodecID id)
350 {
351     AVCodec *p;
352     p = first_avcodec;
353     while (p) {
354         if (p->encode != NULL && p->id == id)
355             return p;
356         p = p->next;
357     }
358     return NULL;
359 }
360
361 AVCodec *avcodec_find_encoder_by_name(const char *name)
362 {
363     AVCodec *p;
364     p = first_avcodec;
365     while (p) {
366         if (p->encode != NULL && strcmp(name,p->name) == 0)
367             return p;
368         p = p->next;
369     }
370     return NULL;
371 }
372
373 AVCodec *avcodec_find_decoder(enum CodecID id)
374 {
375     AVCodec *p;
376     p = first_avcodec;
377     while (p) {
378         if (p->decode != NULL && p->id == id)
379             return p;
380         p = p->next;
381     }
382     return NULL;
383 }
384
385 AVCodec *avcodec_find_decoder_by_name(const char *name)
386 {
387     AVCodec *p;
388     p = first_avcodec;
389     while (p) {
390         if (p->decode != NULL && strcmp(name,p->name) == 0)
391             return p;
392         p = p->next;
393     }
394     return NULL;
395 }
396
397 AVCodec *avcodec_find(enum CodecID id)
398 {
399     AVCodec *p;
400     p = first_avcodec;
401     while (p) {
402         if (p->id == id)
403             return p;
404         p = p->next;
405     }
406     return NULL;
407 }
408
409 const char *pix_fmt_str[] = {
410     "yuv420p",
411     "yuv422",
412     "rgb24",
413     "bgr24",
414     "yuv422p",
415     "yuv444p",
416     "rgba32",
417     "bgra32",
418     "yuv410p",
419     "yuv411p",
420 };
421
422 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
423 {
424     const char *codec_name;
425     AVCodec *p;
426     char buf1[32];
427     char channels_str[100];
428     int bitrate;
429
430     if (encode)
431         p = avcodec_find_encoder(enc->codec_id);
432     else
433         p = avcodec_find_decoder(enc->codec_id);
434
435     if (p) {
436         codec_name = p->name;
437     } else if (enc->codec_name[0] != '\0') {
438         codec_name = enc->codec_name;
439     } else {
440         /* output avi tags */
441         if (enc->codec_type == CODEC_TYPE_VIDEO) {
442             snprintf(buf1, sizeof(buf1), "%c%c%c%c", 
443                      enc->codec_tag & 0xff,
444                      (enc->codec_tag >> 8) & 0xff,
445                      (enc->codec_tag >> 16) & 0xff,
446                      (enc->codec_tag >> 24) & 0xff);
447         } else {
448             snprintf(buf1, sizeof(buf1), "0x%04x", enc->codec_tag);
449         }
450         codec_name = buf1;
451     }
452
453     switch(enc->codec_type) {
454     case CODEC_TYPE_VIDEO:
455         snprintf(buf, buf_size,
456                  "Video: %s%s",
457                  codec_name, enc->flags & CODEC_FLAG_HQ ? " (hq)" : "");
458         if (enc->codec_id == CODEC_ID_RAWVIDEO) {
459             snprintf(buf + strlen(buf), buf_size - strlen(buf),
460                      ", %s",
461                      pix_fmt_str[enc->pix_fmt]);
462         }
463         if (enc->width) {
464             snprintf(buf + strlen(buf), buf_size - strlen(buf),
465                      ", %dx%d, %0.2f fps",
466                      enc->width, enc->height, 
467                      (float)enc->frame_rate / FRAME_RATE_BASE);
468         }
469         if (encode) {
470             snprintf(buf + strlen(buf), buf_size - strlen(buf),
471                      ", q=%d-%d", enc->qmin, enc->qmax);
472         }
473         bitrate = enc->bit_rate;
474         break;
475     case CODEC_TYPE_AUDIO:
476         snprintf(buf, buf_size,
477                  "Audio: %s",
478                  codec_name);
479         switch (enc->channels) {
480             case 1:
481                 strcpy(channels_str, "mono");
482                 break;
483             case 2:
484                 strcpy(channels_str, "stereo");
485                 break;
486             case 6:
487                 strcpy(channels_str, "5:1");
488                 break;
489             default:
490                 sprintf(channels_str, "%d channels", enc->channels);
491                 break;
492         }
493         if (enc->sample_rate) {
494             snprintf(buf + strlen(buf), buf_size - strlen(buf),
495                      ", %d Hz, %s",
496                      enc->sample_rate,
497                      channels_str);
498         }
499         
500         /* for PCM codecs, compute bitrate directly */
501         switch(enc->codec_id) {
502         case CODEC_ID_PCM_S16LE:
503         case CODEC_ID_PCM_S16BE:
504         case CODEC_ID_PCM_U16LE:
505         case CODEC_ID_PCM_U16BE:
506             bitrate = enc->sample_rate * enc->channels * 16;
507             break;
508         case CODEC_ID_PCM_S8:
509         case CODEC_ID_PCM_U8:
510         case CODEC_ID_PCM_ALAW:
511         case CODEC_ID_PCM_MULAW:
512             bitrate = enc->sample_rate * enc->channels * 8;
513             break;
514         default:
515             bitrate = enc->bit_rate;
516             break;
517         }
518         break;
519     default:
520         av_abort();
521     }
522     if (encode) {
523         if (enc->flags & CODEC_FLAG_PASS1)
524             snprintf(buf + strlen(buf), buf_size - strlen(buf),
525                      ", pass 1");
526         if (enc->flags & CODEC_FLAG_PASS2)
527             snprintf(buf + strlen(buf), buf_size - strlen(buf),
528                      ", pass 2");
529     }
530     if (bitrate != 0) {
531         snprintf(buf + strlen(buf), buf_size - strlen(buf), 
532                  ", %d kb/s", bitrate / 1000);
533     }
534 }
535
536 /* Picture field are filled with 'ptr' addresses */
537 void avpicture_fill(AVPicture *picture, UINT8 *ptr,
538                     int pix_fmt, int width, int height)
539 {
540     int size;
541
542     size = width * height;
543     switch(pix_fmt) {
544     case PIX_FMT_YUV420P:
545         picture->data[0] = ptr;
546         picture->data[1] = picture->data[0] + size;
547         picture->data[2] = picture->data[1] + size / 4;
548         picture->linesize[0] = width;
549         picture->linesize[1] = width / 2;
550         picture->linesize[2] = width / 2;
551         break;
552     case PIX_FMT_YUV422P:
553         picture->data[0] = ptr;
554         picture->data[1] = picture->data[0] + size;
555         picture->data[2] = picture->data[1] + size / 2;
556         picture->linesize[0] = width;
557         picture->linesize[1] = width / 2;
558         picture->linesize[2] = width / 2;
559         break;
560     case PIX_FMT_YUV444P:
561         picture->data[0] = ptr;
562         picture->data[1] = picture->data[0] + size;
563         picture->data[2] = picture->data[1] + size;
564         picture->linesize[0] = width;
565         picture->linesize[1] = width;
566         picture->linesize[2] = width;
567         break;
568     case PIX_FMT_RGB24:
569     case PIX_FMT_BGR24:
570         picture->data[0] = ptr;
571         picture->data[1] = NULL;
572         picture->data[2] = NULL;
573         picture->linesize[0] = width * 3;
574         break;
575     case PIX_FMT_RGBA32:
576     case PIX_FMT_BGRA32:
577         picture->data[0] = ptr;
578         picture->data[1] = NULL;
579         picture->data[2] = NULL;
580         picture->linesize[0] = width * 4;
581         break;
582     case PIX_FMT_YUV422:
583         picture->data[0] = ptr;
584         picture->data[1] = NULL;
585         picture->data[2] = NULL;
586         picture->linesize[0] = width * 2;
587         break;
588     default:
589         picture->data[0] = NULL;
590         picture->data[1] = NULL;
591         picture->data[2] = NULL;
592         break;
593     }
594 }
595
596 int avpicture_get_size(int pix_fmt, int width, int height)
597 {
598     int size;
599
600     size = width * height;
601     switch(pix_fmt) {
602     case PIX_FMT_YUV420P:
603         size = (size * 3) / 2;
604         break;
605     case PIX_FMT_YUV422P:
606         size = (size * 2);
607         break;
608     case PIX_FMT_YUV444P:
609         size = (size * 3);
610         break;
611     case PIX_FMT_RGB24:
612     case PIX_FMT_BGR24:
613         size = (size * 3);
614         break;
615     case PIX_FMT_RGBA32:
616     case PIX_FMT_BGRA32:
617         size = (size * 4);
618         break;
619     case PIX_FMT_YUV422:
620         size = (size * 2);
621         break;
622     default:
623         size = -1;
624         break;
625     }
626     return size;
627 }
628
629 unsigned avcodec_version( void )
630 {
631   return LIBAVCODEC_VERSION_INT;
632 }
633
634 unsigned avcodec_build( void )
635 {
636   return LIBAVCODEC_BUILD;
637 }
638
639 /* must be called before any other functions */
640 void avcodec_init(void)
641 {
642     static int inited = 0;
643
644     if (inited != 0)
645         return;
646     inited = 1;
647
648     //dsputil_init();
649 }
650
651 /* this can be called after seeking and before trying to decode the next keyframe */
652 void avcodec_flush_buffers(AVCodecContext *avctx)
653 {
654     int i;
655     MpegEncContext *s = avctx->priv_data;
656     
657     switch(avctx->codec_id){
658     case CODEC_ID_MPEG1VIDEO:
659     case CODEC_ID_H263:
660     case CODEC_ID_RV10:
661     case CODEC_ID_MJPEG:
662     case CODEC_ID_MJPEGB:
663     case CODEC_ID_MPEG4:
664     case CODEC_ID_MSMPEG4V1:
665     case CODEC_ID_MSMPEG4V2:
666     case CODEC_ID_MSMPEG4V3:
667     case CODEC_ID_WMV1:
668     case CODEC_ID_WMV2:
669     case CODEC_ID_H263P:
670     case CODEC_ID_H263I:
671     case CODEC_ID_SVQ1:
672         for(i=0; i<MAX_PICTURE_COUNT; i++){
673            if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
674                                         || s->picture[i].type == FF_BUFFER_TYPE_USER))
675             avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
676         }
677         break;
678     default:
679         //FIXME
680         break;
681     }
682 }
683
684 static int raw_encode_init(AVCodecContext *s)
685 {
686     return 0;
687 }
688
689 static int raw_decode_frame(AVCodecContext *avctx,
690                             void *data, int *data_size,
691                             UINT8 *buf, int buf_size)
692 {
693     return -1;
694 }
695
696 static int raw_encode_frame(AVCodecContext *avctx,
697                             unsigned char *frame, int buf_size, void *data)
698 {
699     return -1;
700 }
701
702 AVCodec rawvideo_codec = {
703     "rawvideo",
704     CODEC_TYPE_VIDEO,
705     CODEC_ID_RAWVIDEO,
706     0,
707     raw_encode_init,
708     raw_encode_frame,
709     NULL,
710     raw_decode_frame,
711 };