Mercurial > libavcodec.hg
annotate utils.c @ 2497:69adfbbdcdeb libavcodec
- samples from mplayer ftp in the "adv" profile seem to have profile=2,
which isn't the advanced one; and indeed, using adv. profile parser fails.
Using normal parser works, and that's what is done
- attempt at taking care of stride for NORM2 bitplane decoding
- duplication of much code from msmpeg4.c; this code isn't yet used, but
goes down as far as the block layer (mainly Transform Type stuff, the
remains are wild editing without checking). Unusable yet, and lacks the AC
decoding (but a step further in bitstream parsing)
patch by anonymous
author | michael |
---|---|
date | Fri, 04 Feb 2005 02:20:38 +0000 |
parents | 36d70fbb31c5 |
children | e25782262d7d |
rev | line source |
---|---|
0 | 1 /* |
2 * utils for libavcodec | |
429 | 3 * Copyright (c) 2001 Fabrice Bellard. |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
4 * Copyright (c) 2003 Michel Bardiaux for the av_log API |
1739
07a484280a82
copyright year update of the files i touched and remembered, things look annoyingly unmaintained otherwise
michael
parents:
1730
diff
changeset
|
5 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at> |
0 | 6 * |
429 | 7 * This library is free software; you can redistribute it and/or |
8 * modify it under the terms of the GNU Lesser General Public | |
9 * License as published by the Free Software Foundation; either | |
10 * version 2 of the License, or (at your option) any later version. | |
0 | 11 * |
429 | 12 * This library is distributed in the hope that it will be useful, |
0 | 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
429 | 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
15 * Lesser General Public License for more details. | |
0 | 16 * |
429 | 17 * You should have received a copy of the GNU Lesser General Public |
18 * License along with this library; if not, write to the Free Software | |
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
0 | 20 */ |
1106 | 21 |
22 /** | |
23 * @file utils.c | |
24 * utils. | |
25 */ | |
26 | |
394 | 27 #include "avcodec.h" |
0 | 28 #include "dsputil.h" |
341 | 29 #include "mpegvideo.h" |
2002
b737b5e96ee0
use AVInteger in av_rescale() so it can finally do 64*64/64 instead of just 64*32/32
michael
parents:
1996
diff
changeset
|
30 #include "integer.h" |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
31 #include <stdarg.h> |
2002
b737b5e96ee0
use AVInteger in av_rescale() so it can finally do 64*64/64 instead of just 64*32/32
michael
parents:
1996
diff
changeset
|
32 #include <limits.h> |
0 | 33 |
2398
582e635cfa08
common.c -> bitstream.c (and the single non bitstream func -> utils.c)
michael
parents:
2370
diff
changeset
|
34 const uint8_t ff_sqrt_tab[128]={ |
582e635cfa08
common.c -> bitstream.c (and the single non bitstream func -> utils.c)
michael
parents:
2370
diff
changeset
|
35 0, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, |
582e635cfa08
common.c -> bitstream.c (and the single non bitstream func -> utils.c)
michael
parents:
2370
diff
changeset
|
36 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, |
582e635cfa08
common.c -> bitstream.c (and the single non bitstream func -> utils.c)
michael
parents:
2370
diff
changeset
|
37 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, |
582e635cfa08
common.c -> bitstream.c (and the single non bitstream func -> utils.c)
michael
parents:
2370
diff
changeset
|
38 9, 9, 9, 9,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,11,11,11,11,11,11,11 |
582e635cfa08
common.c -> bitstream.c (and the single non bitstream func -> utils.c)
michael
parents:
2370
diff
changeset
|
39 }; |
582e635cfa08
common.c -> bitstream.c (and the single non bitstream func -> utils.c)
michael
parents:
2370
diff
changeset
|
40 |
582e635cfa08
common.c -> bitstream.c (and the single non bitstream func -> utils.c)
michael
parents:
2370
diff
changeset
|
41 const uint8_t ff_log2_tab[256]={ |
582e635cfa08
common.c -> bitstream.c (and the single non bitstream func -> utils.c)
michael
parents:
2370
diff
changeset
|
42 0,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4, |
582e635cfa08
common.c -> bitstream.c (and the single non bitstream func -> utils.c)
michael
parents:
2370
diff
changeset
|
43 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5, |
582e635cfa08
common.c -> bitstream.c (and the single non bitstream func -> utils.c)
michael
parents:
2370
diff
changeset
|
44 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6, |
582e635cfa08
common.c -> bitstream.c (and the single non bitstream func -> utils.c)
michael
parents:
2370
diff
changeset
|
45 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6, |
582e635cfa08
common.c -> bitstream.c (and the single non bitstream func -> utils.c)
michael
parents:
2370
diff
changeset
|
46 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, |
582e635cfa08
common.c -> bitstream.c (and the single non bitstream func -> utils.c)
michael
parents:
2370
diff
changeset
|
47 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, |
582e635cfa08
common.c -> bitstream.c (and the single non bitstream func -> utils.c)
michael
parents:
2370
diff
changeset
|
48 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, |
582e635cfa08
common.c -> bitstream.c (and the single non bitstream func -> utils.c)
michael
parents:
2370
diff
changeset
|
49 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7 |
582e635cfa08
common.c -> bitstream.c (and the single non bitstream func -> utils.c)
michael
parents:
2370
diff
changeset
|
50 }; |
582e635cfa08
common.c -> bitstream.c (and the single non bitstream func -> utils.c)
michael
parents:
2370
diff
changeset
|
51 |
2231 | 52 void avcodec_default_free_buffers(AVCodecContext *s); |
1994 | 53 |
862 | 54 void *av_mallocz(unsigned int size) |
394 | 55 { |
56 void *ptr; | |
908 | 57 |
394 | 58 ptr = av_malloc(size); |
59 if (!ptr) | |
60 return NULL; | |
61 memset(ptr, 0, size); | |
62 return ptr; | |
63 } | |
64 | |
1031
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
998
diff
changeset
|
65 char *av_strdup(const char *s) |
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
998
diff
changeset
|
66 { |
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
998
diff
changeset
|
67 char *ptr; |
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
998
diff
changeset
|
68 int len; |
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
998
diff
changeset
|
69 len = strlen(s) + 1; |
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
998
diff
changeset
|
70 ptr = av_malloc(len); |
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
998
diff
changeset
|
71 if (!ptr) |
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
998
diff
changeset
|
72 return NULL; |
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
998
diff
changeset
|
73 memcpy(ptr, s, len); |
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
998
diff
changeset
|
74 return ptr; |
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
998
diff
changeset
|
75 } |
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
998
diff
changeset
|
76 |
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
998
diff
changeset
|
77 /** |
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
998
diff
changeset
|
78 * realloc which does nothing if the block is large enough |
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
998
diff
changeset
|
79 */ |
1057 | 80 void *av_fast_realloc(void *ptr, unsigned int *size, unsigned int min_size) |
1031
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
998
diff
changeset
|
81 { |
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
998
diff
changeset
|
82 if(min_size < *size) |
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
998
diff
changeset
|
83 return ptr; |
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
998
diff
changeset
|
84 |
2422 | 85 *size= FFMAX(17*min_size/16 + 32, min_size); |
1031
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
998
diff
changeset
|
86 |
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
998
diff
changeset
|
87 return av_realloc(ptr, *size); |
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
998
diff
changeset
|
88 } |
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
998
diff
changeset
|
89 |
19de1445beb2
use av_malloc() functions - added av_strdup and av_realloc()
bellard
parents:
998
diff
changeset
|
90 |
902
6acc8394960d
* two functions to handle allocation of static data more simple
kabi
parents:
862
diff
changeset
|
91 static unsigned int last_static = 0; |
1900
5cde80c5d929
static allocation rewrite (old code was plain a broken mess)
michael
parents:
1858
diff
changeset
|
92 static unsigned int allocated_static = 0; |
5cde80c5d929
static allocation rewrite (old code was plain a broken mess)
michael
parents:
1858
diff
changeset
|
93 static void** array_static = NULL; |
5cde80c5d929
static allocation rewrite (old code was plain a broken mess)
michael
parents:
1858
diff
changeset
|
94 |
5cde80c5d929
static allocation rewrite (old code was plain a broken mess)
michael
parents:
1858
diff
changeset
|
95 /** |
5cde80c5d929
static allocation rewrite (old code was plain a broken mess)
michael
parents:
1858
diff
changeset
|
96 * allocation of static arrays - do not use for normal allocation. |
5cde80c5d929
static allocation rewrite (old code was plain a broken mess)
michael
parents:
1858
diff
changeset
|
97 */ |
5cde80c5d929
static allocation rewrite (old code was plain a broken mess)
michael
parents:
1858
diff
changeset
|
98 void *av_mallocz_static(unsigned int size) |
902
6acc8394960d
* two functions to handle allocation of static data more simple
kabi
parents:
862
diff
changeset
|
99 { |
6acc8394960d
* two functions to handle allocation of static data more simple
kabi
parents:
862
diff
changeset
|
100 void *ptr = av_mallocz(size); |
6acc8394960d
* two functions to handle allocation of static data more simple
kabi
parents:
862
diff
changeset
|
101 |
1900
5cde80c5d929
static allocation rewrite (old code was plain a broken mess)
michael
parents:
1858
diff
changeset
|
102 if(ptr){ |
1901 | 103 array_static =av_fast_realloc(array_static, &allocated_static, sizeof(void*)*(last_static+1)); |
2422 | 104 if(!array_static) |
105 return NULL; | |
1900
5cde80c5d929
static allocation rewrite (old code was plain a broken mess)
michael
parents:
1858
diff
changeset
|
106 array_static[last_static++] = ptr; |
902
6acc8394960d
* two functions to handle allocation of static data more simple
kabi
parents:
862
diff
changeset
|
107 } |
1900
5cde80c5d929
static allocation rewrite (old code was plain a broken mess)
michael
parents:
1858
diff
changeset
|
108 |
902
6acc8394960d
* two functions to handle allocation of static data more simple
kabi
parents:
862
diff
changeset
|
109 return ptr; |
6acc8394960d
* two functions to handle allocation of static data more simple
kabi
parents:
862
diff
changeset
|
110 } |
1900
5cde80c5d929
static allocation rewrite (old code was plain a broken mess)
michael
parents:
1858
diff
changeset
|
111 |
5cde80c5d929
static allocation rewrite (old code was plain a broken mess)
michael
parents:
1858
diff
changeset
|
112 /** |
2370
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2362
diff
changeset
|
113 * same as above, but does realloc |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2362
diff
changeset
|
114 */ |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2362
diff
changeset
|
115 |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2362
diff
changeset
|
116 void *av_realloc_static(void *ptr, unsigned int size) |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2362
diff
changeset
|
117 { |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2362
diff
changeset
|
118 int i; |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2362
diff
changeset
|
119 if(!ptr) |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2362
diff
changeset
|
120 return av_mallocz_static(size); |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2362
diff
changeset
|
121 /* Look for the old ptr */ |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2362
diff
changeset
|
122 for(i = 0; i < last_static; i++) { |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2362
diff
changeset
|
123 if(array_static[i] == ptr) { |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2362
diff
changeset
|
124 array_static[i] = av_realloc(array_static[i], size); |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2362
diff
changeset
|
125 return array_static[i]; |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2362
diff
changeset
|
126 } |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2362
diff
changeset
|
127 } |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2362
diff
changeset
|
128 return NULL; |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2362
diff
changeset
|
129 |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2362
diff
changeset
|
130 } |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2362
diff
changeset
|
131 |
26560d4fdb1f
Memory leak fix patch by (Burkhard Plaum <plaum >at< ipf.uni-stuttgart )dot( de>)
michael
parents:
2362
diff
changeset
|
132 /** |
1900
5cde80c5d929
static allocation rewrite (old code was plain a broken mess)
michael
parents:
1858
diff
changeset
|
133 * free all static arrays and reset pointers to 0. |
5cde80c5d929
static allocation rewrite (old code was plain a broken mess)
michael
parents:
1858
diff
changeset
|
134 */ |
1282 | 135 void av_free_static(void) |
902
6acc8394960d
* two functions to handle allocation of static data more simple
kabi
parents:
862
diff
changeset
|
136 { |
1900
5cde80c5d929
static allocation rewrite (old code was plain a broken mess)
michael
parents:
1858
diff
changeset
|
137 while(last_static){ |
5cde80c5d929
static allocation rewrite (old code was plain a broken mess)
michael
parents:
1858
diff
changeset
|
138 av_freep(&array_static[--last_static]); |
902
6acc8394960d
* two functions to handle allocation of static data more simple
kabi
parents:
862
diff
changeset
|
139 } |
1900
5cde80c5d929
static allocation rewrite (old code was plain a broken mess)
michael
parents:
1858
diff
changeset
|
140 av_freep(&array_static); |
902
6acc8394960d
* two functions to handle allocation of static data more simple
kabi
parents:
862
diff
changeset
|
141 } |
6acc8394960d
* two functions to handle allocation of static data more simple
kabi
parents:
862
diff
changeset
|
142 |
1854 | 143 /** |
144 * Frees memory and sets the pointer to NULL. | |
145 * @param arg pointer to the pointer which should be freed | |
146 */ | |
147 void av_freep(void *arg) | |
400 | 148 { |
1854 | 149 void **ptr= (void**)arg; |
400 | 150 av_free(*ptr); |
151 *ptr = NULL; | |
152 } | |
153 | |
0 | 154 /* encoder management */ |
2169
db8baace74d8
Minor Patch for shared libs on Mac OSX by (Bill May <wmay at cisco dot com>)
michael
parents:
2167
diff
changeset
|
155 AVCodec *first_avcodec = NULL; |
0 | 156 |
157 void register_avcodec(AVCodec *format) | |
158 { | |
159 AVCodec **p; | |
160 p = &first_avcodec; | |
161 while (*p != NULL) p = &(*p)->next; | |
162 *p = format; | |
163 format->next = NULL; | |
164 } | |
165 | |
2270 | 166 void avcodec_set_dimensions(AVCodecContext *s, int width, int height){ |
167 s->coded_width = width; | |
168 s->coded_height= height; | |
169 s->width = -((-width )>>s->lowres); | |
170 s->height= -((-height)>>s->lowres); | |
171 } | |
172 | |
1214 | 173 typedef struct InternalBuffer{ |
903 | 174 int last_pic_num; |
1214 | 175 uint8_t *base[4]; |
903 | 176 uint8_t *data[4]; |
1588
de5e2acd0f80
initalize various uninitalized variables and avoid coded_picture_number as its not always correct (later should be reversed after fixing the picture_number mess)
michael
parents:
1585
diff
changeset
|
177 int linesize[4]; |
1214 | 178 }InternalBuffer; |
179 | |
180 #define INTERNAL_BUFFER_SIZE 32 | |
903 | 181 |
1538 | 182 #define ALIGN(x, a) (((x)+(a)-1)&~((a)-1)) |
183 | |
184 void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height){ | |
185 int w_align= 1; | |
186 int h_align= 1; | |
187 | |
188 switch(s->pix_fmt){ | |
189 case PIX_FMT_YUV420P: | |
190 case PIX_FMT_YUV422: | |
2137
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
2125
diff
changeset
|
191 case PIX_FMT_UYVY422: |
1538 | 192 case PIX_FMT_YUV422P: |
193 case PIX_FMT_YUV444P: | |
194 case PIX_FMT_GRAY8: | |
195 case PIX_FMT_YUVJ420P: | |
196 case PIX_FMT_YUVJ422P: | |
197 case PIX_FMT_YUVJ444P: | |
198 w_align= 16; //FIXME check for non mpeg style codecs and use less alignment | |
199 h_align= 16; | |
200 break; | |
201 case PIX_FMT_YUV411P: | |
2309 | 202 case PIX_FMT_UYVY411: |
1538 | 203 w_align=32; |
204 h_align=8; | |
205 break; | |
206 case PIX_FMT_YUV410P: | |
207 if(s->codec_id == CODEC_ID_SVQ1){ | |
208 w_align=64; | |
209 h_align=64; | |
210 } | |
2104 | 211 case PIX_FMT_RGB555: |
212 if(s->codec_id == CODEC_ID_RPZA){ | |
213 w_align=4; | |
214 h_align=4; | |
215 } | |
216 case PIX_FMT_PAL8: | |
217 if(s->codec_id == CODEC_ID_SMC){ | |
218 w_align=4; | |
219 h_align=4; | |
220 } | |
1538 | 221 break; |
2418
82af834636c2
Check pointers before writing to memory, fix possible integer overflows
rtognimp
parents:
2398
diff
changeset
|
222 case PIX_FMT_BGR24: |
82af834636c2
Check pointers before writing to memory, fix possible integer overflows
rtognimp
parents:
2398
diff
changeset
|
223 if((s->codec_id == CODEC_ID_MSZH) || (s->codec_id == CODEC_ID_ZLIB)){ |
82af834636c2
Check pointers before writing to memory, fix possible integer overflows
rtognimp
parents:
2398
diff
changeset
|
224 w_align=4; |
82af834636c2
Check pointers before writing to memory, fix possible integer overflows
rtognimp
parents:
2398
diff
changeset
|
225 h_align=4; |
82af834636c2
Check pointers before writing to memory, fix possible integer overflows
rtognimp
parents:
2398
diff
changeset
|
226 } |
82af834636c2
Check pointers before writing to memory, fix possible integer overflows
rtognimp
parents:
2398
diff
changeset
|
227 break; |
1538 | 228 default: |
229 w_align= 1; | |
230 h_align= 1; | |
231 break; | |
232 } | |
233 | |
234 *width = ALIGN(*width , w_align); | |
235 *height= ALIGN(*height, h_align); | |
236 } | |
237 | |
2422 | 238 int avcodec_check_dimensions(void *av_log_ctx, unsigned int w, unsigned int h){ |
239 if((int)w>0 && (int)h>0 && (w+128)*(uint64_t)(h+128) < INT_MAX/4) | |
240 return 0; | |
241 | |
242 av_log(av_log_ctx, AV_LOG_ERROR, "picture size invalid (%ux%u)\n", w, h); | |
243 return -1; | |
244 } | |
245 | |
925 | 246 int avcodec_default_get_buffer(AVCodecContext *s, AVFrame *pic){ |
903 | 247 int i; |
1538 | 248 int w= s->width; |
249 int h= s->height; | |
1214 | 250 InternalBuffer *buf; |
1588
de5e2acd0f80
initalize various uninitalized variables and avoid coded_picture_number as its not always correct (later should be reversed after fixing the picture_number mess)
michael
parents:
1585
diff
changeset
|
251 int *picture_number; |
2422 | 252 |
924 | 253 assert(pic->data[0]==NULL); |
1214 | 254 assert(INTERNAL_BUFFER_SIZE > s->internal_buffer_count); |
903 | 255 |
2422 | 256 if(avcodec_check_dimensions(s,w,h)) |
257 return -1; | |
258 | |
1214 | 259 if(s->internal_buffer==NULL){ |
260 s->internal_buffer= av_mallocz(INTERNAL_BUFFER_SIZE*sizeof(InternalBuffer)); | |
261 } | |
262 #if 0 | |
263 s->internal_buffer= av_fast_realloc( | |
264 s->internal_buffer, | |
265 &s->internal_buffer_size, | |
266 sizeof(InternalBuffer)*FFMAX(99, s->internal_buffer_count+1)/*FIXME*/ | |
267 ); | |
268 #endif | |
269 | |
270 buf= &((InternalBuffer*)s->internal_buffer)[s->internal_buffer_count]; | |
1588
de5e2acd0f80
initalize various uninitalized variables and avoid coded_picture_number as its not always correct (later should be reversed after fixing the picture_number mess)
michael
parents:
1585
diff
changeset
|
271 picture_number= &(((InternalBuffer*)s->internal_buffer)[INTERNAL_BUFFER_SIZE-1]).last_pic_num; //FIXME ugly hack |
de5e2acd0f80
initalize various uninitalized variables and avoid coded_picture_number as its not always correct (later should be reversed after fixing the picture_number mess)
michael
parents:
1585
diff
changeset
|
272 (*picture_number)++; |
de5e2acd0f80
initalize various uninitalized variables and avoid coded_picture_number as its not always correct (later should be reversed after fixing the picture_number mess)
michael
parents:
1585
diff
changeset
|
273 |
1214 | 274 if(buf->base[0]){ |
1588
de5e2acd0f80
initalize various uninitalized variables and avoid coded_picture_number as its not always correct (later should be reversed after fixing the picture_number mess)
michael
parents:
1585
diff
changeset
|
275 pic->age= *picture_number - buf->last_pic_num; |
de5e2acd0f80
initalize various uninitalized variables and avoid coded_picture_number as its not always correct (later should be reversed after fixing the picture_number mess)
michael
parents:
1585
diff
changeset
|
276 buf->last_pic_num= *picture_number; |
903 | 277 }else{ |
1538 | 278 int h_chroma_shift, v_chroma_shift; |
2324 | 279 int pixel_size; |
903 | 280 |
281 avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift); | |
1538 | 282 |
903 | 283 switch(s->pix_fmt){ |
1291 | 284 case PIX_FMT_RGB555: |
285 case PIX_FMT_RGB565: | |
903 | 286 case PIX_FMT_YUV422: |
2137
ef47c0b1ff28
UYVY support patch by ("Todd.Kirby" <doubleshot at pacbell dot net>)
michael
parents:
2125
diff
changeset
|
287 case PIX_FMT_UYVY422: |
903 | 288 pixel_size=2; |
289 break; | |
290 case PIX_FMT_RGB24: | |
291 case PIX_FMT_BGR24: | |
292 pixel_size=3; | |
293 break; | |
294 case PIX_FMT_RGBA32: | |
295 pixel_size=4; | |
296 break; | |
297 default: | |
298 pixel_size=1; | |
299 } | |
1538 | 300 |
301 avcodec_align_dimensions(s, &w, &h); | |
302 | |
903 | 303 if(!(s->flags&CODEC_FLAG_EMU_EDGE)){ |
304 w+= EDGE_WIDTH*2; | |
305 h+= EDGE_WIDTH*2; | |
306 } | |
307 | |
1214 | 308 buf->last_pic_num= -256*256*256*64; |
903 | 309 |
310 for(i=0; i<3; i++){ | |
1165 | 311 const int h_shift= i==0 ? 0 : h_chroma_shift; |
312 const int v_shift= i==0 ? 0 : v_chroma_shift; | |
903 | 313 |
1798
a3da4b429984
ppc chroma mess workaround (real bug is that the motion compensation code assumes that 2*uvlinesize == linesize and fixing this would mean a slowdown)
michael
parents:
1776
diff
changeset
|
314 //FIXME next ensures that linesize= 2^x uvlinesize, thats needed because some MC code assumes it |
2324 | 315 buf->linesize[i]= ALIGN(pixel_size*w>>h_shift, STRIDE_ALIGN<<(h_chroma_shift-h_shift)); |
903 | 316 |
2426
1ee03f2a6cd5
av_malloc vs av_mallocz patch by (Kurosu <kurosu inforezo org>)
michael
parents:
2423
diff
changeset
|
317 buf->base[i]= av_malloc((buf->linesize[i]*h>>v_shift)+16); //FIXME 16 |
1214 | 318 if(buf->base[i]==NULL) return -1; |
1588
de5e2acd0f80
initalize various uninitalized variables and avoid coded_picture_number as its not always correct (later should be reversed after fixing the picture_number mess)
michael
parents:
1585
diff
changeset
|
319 memset(buf->base[i], 128, buf->linesize[i]*h>>v_shift); |
903 | 320 |
321 if(s->flags&CODEC_FLAG_EMU_EDGE) | |
1214 | 322 buf->data[i] = buf->base[i]; |
903 | 323 else |
2324 | 324 buf->data[i] = buf->base[i] + ALIGN((buf->linesize[i]*EDGE_WIDTH>>v_shift) + (EDGE_WIDTH>>h_shift), STRIDE_ALIGN); |
903 | 325 } |
326 pic->age= 256*256*256*64; | |
327 } | |
1588
de5e2acd0f80
initalize various uninitalized variables and avoid coded_picture_number as its not always correct (later should be reversed after fixing the picture_number mess)
michael
parents:
1585
diff
changeset
|
328 pic->type= FF_BUFFER_TYPE_INTERNAL; |
903 | 329 |
1214 | 330 for(i=0; i<4; i++){ |
331 pic->base[i]= buf->base[i]; | |
332 pic->data[i]= buf->data[i]; | |
1588
de5e2acd0f80
initalize various uninitalized variables and avoid coded_picture_number as its not always correct (later should be reversed after fixing the picture_number mess)
michael
parents:
1585
diff
changeset
|
333 pic->linesize[i]= buf->linesize[i]; |
1214 | 334 } |
335 s->internal_buffer_count++; | |
336 | |
903 | 337 return 0; |
338 } | |
339 | |
925 | 340 void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic){ |
903 | 341 int i; |
1214 | 342 InternalBuffer *buf, *last, temp; |
343 | |
924 | 344 assert(pic->type==FF_BUFFER_TYPE_INTERNAL); |
1396 | 345 assert(s->internal_buffer_count); |
1214 | 346 |
1455 | 347 buf = NULL; /* avoids warning */ |
1214 | 348 for(i=0; i<s->internal_buffer_count; i++){ //just 3-5 checks so is not worth to optimize |
349 buf= &((InternalBuffer*)s->internal_buffer)[i]; | |
350 if(buf->data[0] == pic->data[0]) | |
351 break; | |
352 } | |
353 assert(i < s->internal_buffer_count); | |
354 s->internal_buffer_count--; | |
355 last = &((InternalBuffer*)s->internal_buffer)[s->internal_buffer_count]; | |
356 | |
357 temp= *buf; | |
358 *buf= *last; | |
359 *last= temp; | |
360 | |
361 for(i=0; i<3; i++){ | |
903 | 362 pic->data[i]=NULL; |
1214 | 363 // pic->base[i]=NULL; |
364 } | |
903 | 365 //printf("R%X\n", pic->opaque); |
366 } | |
367 | |
1630 | 368 int avcodec_default_reget_buffer(AVCodecContext *s, AVFrame *pic){ |
369 AVFrame temp_pic; | |
370 int i; | |
371 | |
372 /* If no picture return a new buffer */ | |
373 if(pic->data[0] == NULL) { | |
374 /* We will copy from buffer, so must be readable */ | |
375 pic->buffer_hints |= FF_BUFFER_HINTS_READABLE; | |
376 return s->get_buffer(s, pic); | |
377 } | |
378 | |
379 /* If internal buffer type return the same buffer */ | |
380 if(pic->type == FF_BUFFER_TYPE_INTERNAL) | |
381 return 0; | |
382 | |
383 /* | |
384 * Not internal type and reget_buffer not overridden, emulate cr buffer | |
385 */ | |
386 temp_pic = *pic; | |
387 for(i = 0; i < 4; i++) | |
388 pic->data[i] = pic->base[i] = NULL; | |
389 pic->opaque = NULL; | |
390 /* Allocate new frame */ | |
391 if (s->get_buffer(s, pic)) | |
392 return -1; | |
393 /* Copy image data from old buffer to new buffer */ | |
394 img_copy((AVPicture*)pic, (AVPicture*)&temp_pic, s->pix_fmt, s->width, | |
395 s->height); | |
396 s->release_buffer(s, &temp_pic); // Release old frame | |
397 return 0; | |
398 } | |
399 | |
1799 | 400 int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2),void **arg, int *ret, int count){ |
401 int i; | |
402 | |
403 for(i=0; i<count; i++){ | |
404 int r= func(c, arg[i]); | |
405 if(ret) ret[i]= r; | |
406 } | |
407 return 0; | |
408 } | |
409 | |
1858 | 410 enum PixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum PixelFormat * fmt){ |
998 | 411 return fmt[0]; |
412 } | |
413 | |
1856 | 414 static const char* context_to_name(void* ptr) { |
415 AVCodecContext *avc= ptr; | |
416 | |
417 if(avc && avc->codec && avc->codec->name) | |
418 return avc->codec->name; | |
419 else | |
420 return "NULL"; | |
421 } | |
422 | |
423 static AVClass av_codec_context_class = { "AVCodecContext", context_to_name }; | |
424 | |
681 | 425 void avcodec_get_context_defaults(AVCodecContext *s){ |
1831
cd2d7fcfab7a
use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents:
1823
diff
changeset
|
426 memset(s, 0, sizeof(AVCodecContext)); |
cd2d7fcfab7a
use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents:
1823
diff
changeset
|
427 |
1856 | 428 s->av_class= &av_codec_context_class; |
685 | 429 s->bit_rate= 800*1000; |
430 s->bit_rate_tolerance= s->bit_rate*10; | |
681 | 431 s->qmin= 2; |
432 s->qmax= 31; | |
2494
36d70fbb31c5
mb_lmin/max to limit the per mb quality for the ratecontrol independant from the frame limits
michael
parents:
2488
diff
changeset
|
433 s->mb_lmin= FF_QP2LAMBDA * 2; |
36d70fbb31c5
mb_lmin/max to limit the per mb quality for the ratecontrol independant from the frame limits
michael
parents:
2488
diff
changeset
|
434 s->mb_lmax= FF_QP2LAMBDA * 31; |
681 | 435 s->rc_eq= "tex^qComp"; |
436 s->qcompress= 0.5; | |
685 | 437 s->max_qdiff= 3; |
438 s->b_quant_factor=1.25; | |
439 s->b_quant_offset=1.25; | |
686
83d2c9d50d7d
fixing i_quant_factor, this should finally fix the bitrate bug with ffserver hopefully
michaelni
parents:
685
diff
changeset
|
440 s->i_quant_factor=-0.8; |
685 | 441 s->i_quant_offset=0.0; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
742
diff
changeset
|
442 s->error_concealment= 3; |
762 | 443 s->error_resilience= 1; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
742
diff
changeset
|
444 s->workaround_bugs= FF_BUG_AUTODETECT; |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
445 s->frame_rate_base= 1; |
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
446 s->frame_rate = 25; |
762 | 447 s->gop_size= 50; |
448 s->me_method= ME_EPZS; | |
903 | 449 s->get_buffer= avcodec_default_get_buffer; |
450 s->release_buffer= avcodec_default_release_buffer; | |
998 | 451 s->get_format= avcodec_default_get_format; |
1799 | 452 s->execute= avcodec_default_execute; |
453 s->thread_count=1; | |
954 | 454 s->me_subpel_quality=8; |
1505
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1456
diff
changeset
|
455 s->lmin= FF_QP2LAMBDA * s->qmin; |
010f76d07a27
use lagrange multipler instead of qp for ratecontrol, this may break some things, tell me ASAP if u notice anything broken
michaelni
parents:
1456
diff
changeset
|
456 s->lmax= FF_QP2LAMBDA * s->qmax; |
1548 | 457 s->sample_aspect_ratio= (AVRational){0,1}; |
1730 | 458 s->ildct_cmp= FF_CMP_VSAD; |
2167 | 459 s->profile= FF_PROFILE_UNKNOWN; |
460 s->level= FF_LEVEL_UNKNOWN; | |
1150 | 461 |
462 s->intra_quant_bias= FF_DEFAULT_QUANT_BIAS; | |
463 s->inter_quant_bias= FF_DEFAULT_QUANT_BIAS; | |
1585
6b224ca24033
revised palette API, courtesy of Roberto Togni (rtogni at freemail.it)
melanson
parents:
1582
diff
changeset
|
464 s->palctrl = NULL; |
1630 | 465 s->reget_buffer= avcodec_default_reget_buffer; |
681 | 466 } |
467 | |
468 /** | |
469 * allocates a AVCodecContext and set it to defaults. | |
470 * this can be deallocated by simply calling free() | |
471 */ | |
703 | 472 AVCodecContext *avcodec_alloc_context(void){ |
1831
cd2d7fcfab7a
use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents:
1823
diff
changeset
|
473 AVCodecContext *avctx= av_malloc(sizeof(AVCodecContext)); |
681 | 474 |
475 if(avctx==NULL) return NULL; | |
476 | |
477 avcodec_get_context_defaults(avctx); | |
478 | |
479 return avctx; | |
480 } | |
481 | |
1831
cd2d7fcfab7a
use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents:
1823
diff
changeset
|
482 void avcodec_get_frame_defaults(AVFrame *pic){ |
cd2d7fcfab7a
use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents:
1823
diff
changeset
|
483 memset(pic, 0, sizeof(AVFrame)); |
cd2d7fcfab7a
use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents:
1823
diff
changeset
|
484 |
cd2d7fcfab7a
use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents:
1823
diff
changeset
|
485 pic->pts= AV_NOPTS_VALUE; |
2488 | 486 pic->key_frame= 1; |
1831
cd2d7fcfab7a
use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents:
1823
diff
changeset
|
487 } |
cd2d7fcfab7a
use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents:
1823
diff
changeset
|
488 |
903 | 489 /** |
925 | 490 * allocates a AVPFrame and set it to defaults. |
903 | 491 * this can be deallocated by simply calling free() |
492 */ | |
925 | 493 AVFrame *avcodec_alloc_frame(void){ |
1831
cd2d7fcfab7a
use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents:
1823
diff
changeset
|
494 AVFrame *pic= av_malloc(sizeof(AVFrame)); |
cd2d7fcfab7a
use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents:
1823
diff
changeset
|
495 |
cd2d7fcfab7a
use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents:
1823
diff
changeset
|
496 if(pic==NULL) return NULL; |
cd2d7fcfab7a
use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents:
1823
diff
changeset
|
497 |
cd2d7fcfab7a
use AVFrame.pts=AV_NOPTS_VALUE instead of AVFrame.pts=0
michael
parents:
1823
diff
changeset
|
498 avcodec_get_frame_defaults(pic); |
903 | 499 |
500 return pic; | |
501 } | |
502 | |
0 | 503 int avcodec_open(AVCodecContext *avctx, AVCodec *codec) |
504 { | |
505 int ret; | |
506 | |
1456
670fca257a69
detect avcodec_open() on an already opened AVCodecContext
michaelni
parents:
1455
diff
changeset
|
507 if(avctx->codec) |
670fca257a69
detect avcodec_open() on an already opened AVCodecContext
michaelni
parents:
1455
diff
changeset
|
508 return -1; |
670fca257a69
detect avcodec_open() on an already opened AVCodecContext
michaelni
parents:
1455
diff
changeset
|
509 |
0 | 510 avctx->codec = codec; |
927 | 511 avctx->codec_id = codec->id; |
0 | 512 avctx->frame_number = 0; |
374
02147e22f8c8
* Don't allocate 0 bytes of memory. It upsets electricFence!
philipjsg
parents:
362
diff
changeset
|
513 if (codec->priv_data_size > 0) { |
02147e22f8c8
* Don't allocate 0 bytes of memory. It upsets electricFence!
philipjsg
parents:
362
diff
changeset
|
514 avctx->priv_data = av_mallocz(codec->priv_data_size); |
02147e22f8c8
* Don't allocate 0 bytes of memory. It upsets electricFence!
philipjsg
parents:
362
diff
changeset
|
515 if (!avctx->priv_data) |
02147e22f8c8
* Don't allocate 0 bytes of memory. It upsets electricFence!
philipjsg
parents:
362
diff
changeset
|
516 return -ENOMEM; |
02147e22f8c8
* Don't allocate 0 bytes of memory. It upsets electricFence!
philipjsg
parents:
362
diff
changeset
|
517 } else { |
02147e22f8c8
* Don't allocate 0 bytes of memory. It upsets electricFence!
philipjsg
parents:
362
diff
changeset
|
518 avctx->priv_data = NULL; |
02147e22f8c8
* Don't allocate 0 bytes of memory. It upsets electricFence!
philipjsg
parents:
362
diff
changeset
|
519 } |
2270 | 520 |
521 if(avctx->coded_width && avctx->coded_height) | |
522 avcodec_set_dimensions(avctx, avctx->coded_width, avctx->coded_height); | |
523 else if(avctx->width && avctx->height) | |
524 avcodec_set_dimensions(avctx, avctx->width, avctx->height); | |
525 | |
2422 | 526 if((avctx->coded_width||avctx->coded_height) && avcodec_check_dimensions(avctx,avctx->coded_width,avctx->coded_height)){ |
527 av_freep(&avctx->priv_data); | |
528 return -1; | |
529 } | |
530 | |
0 | 531 ret = avctx->codec->init(avctx); |
532 if (ret < 0) { | |
394 | 533 av_freep(&avctx->priv_data); |
0 | 534 return ret; |
535 } | |
536 return 0; | |
537 } | |
538 | |
1064 | 539 int avcodec_encode_audio(AVCodecContext *avctx, uint8_t *buf, int buf_size, |
0 | 540 const short *samples) |
541 { | |
2422 | 542 if(buf_size < FF_MIN_BUFFER_SIZE && 0){ |
543 av_log(avctx, AV_LOG_ERROR, "buffer smaller then minimum size\n"); | |
544 return -1; | |
545 } | |
2091 | 546 if((avctx->codec->capabilities & CODEC_CAP_DELAY) || samples){ |
547 int ret = avctx->codec->encode(avctx, buf, buf_size, (void *)samples); | |
548 avctx->frame_number++; | |
549 return ret; | |
550 }else | |
551 return 0; | |
0 | 552 } |
553 | |
1064 | 554 int avcodec_encode_video(AVCodecContext *avctx, uint8_t *buf, int buf_size, |
925 | 555 const AVFrame *pict) |
0 | 556 { |
2422 | 557 if(buf_size < FF_MIN_BUFFER_SIZE){ |
558 av_log(avctx, AV_LOG_ERROR, "buffer smaller then minimum size\n"); | |
559 return -1; | |
560 } | |
561 if(avcodec_check_dimensions(avctx,avctx->width,avctx->height)) | |
562 return -1; | |
2091 | 563 if((avctx->codec->capabilities & CODEC_CAP_DELAY) || pict){ |
564 int ret = avctx->codec->encode(avctx, buf, buf_size, (void *)pict); | |
565 avctx->frame_number++; | |
566 emms_c(); //needed to avoid a emms_c() call before every return; | |
814 | 567 |
2091 | 568 return ret; |
569 }else | |
570 return 0; | |
0 | 571 } |
572 | |
1249 | 573 /** |
574 * decode a frame. | |
575 * @param buf bitstream buffer, must be FF_INPUT_BUFFER_PADDING_SIZE larger then the actual read bytes | |
576 * because some optimized bitstream readers read 32 or 64 bit at once and could read over the end | |
577 * @param buf_size the size of the buffer in bytes | |
578 * @param got_picture_ptr zero if no frame could be decompressed, Otherwise, it is non zero | |
579 * @return -1 if error, otherwise return the number of | |
580 * bytes used. | |
581 */ | |
925 | 582 int avcodec_decode_video(AVCodecContext *avctx, AVFrame *picture, |
0 | 583 int *got_picture_ptr, |
1064 | 584 uint8_t *buf, int buf_size) |
0 | 585 { |
586 int ret; | |
903 | 587 |
2028 | 588 *got_picture_ptr= 0; |
2422 | 589 if((avctx->coded_width||avctx->coded_height) && avcodec_check_dimensions(avctx,avctx->coded_width,avctx->coded_height)) |
590 return -1; | |
2453 | 591 if((avctx->codec->capabilities & CODEC_CAP_DELAY) || buf_size){ |
592 ret = avctx->codec->decode(avctx, picture, got_picture_ptr, | |
593 buf, buf_size); | |
814 | 594 |
2453 | 595 emms_c(); //needed to avoid a emms_c() call before every return; |
903 | 596 |
2453 | 597 if (*got_picture_ptr) |
598 avctx->frame_number++; | |
599 }else | |
600 ret= 0; | |
601 | |
0 | 602 return ret; |
603 } | |
604 | |
605 /* decode an audio frame. return -1 if error, otherwise return the | |
606 *number of bytes used. If no frame could be decompressed, | |
607 *frame_size_ptr is zero. Otherwise, it is the decompressed frame | |
608 *size in BYTES. */ | |
1064 | 609 int avcodec_decode_audio(AVCodecContext *avctx, int16_t *samples, |
0 | 610 int *frame_size_ptr, |
1064 | 611 uint8_t *buf, int buf_size) |
0 | 612 { |
613 int ret; | |
614 | |
2028 | 615 *frame_size_ptr= 0; |
0 | 616 ret = avctx->codec->decode(avctx, samples, frame_size_ptr, |
617 buf, buf_size); | |
618 avctx->frame_number++; | |
619 return ret; | |
620 } | |
621 | |
622 int avcodec_close(AVCodecContext *avctx) | |
623 { | |
624 if (avctx->codec->close) | |
625 avctx->codec->close(avctx); | |
1994 | 626 avcodec_default_free_buffers(avctx); |
394 | 627 av_freep(&avctx->priv_data); |
0 | 628 avctx->codec = NULL; |
629 return 0; | |
630 } | |
631 | |
632 AVCodec *avcodec_find_encoder(enum CodecID id) | |
633 { | |
634 AVCodec *p; | |
635 p = first_avcodec; | |
636 while (p) { | |
637 if (p->encode != NULL && p->id == id) | |
638 return p; | |
639 p = p->next; | |
640 } | |
641 return NULL; | |
642 } | |
643 | |
177 | 644 AVCodec *avcodec_find_encoder_by_name(const char *name) |
645 { | |
646 AVCodec *p; | |
647 p = first_avcodec; | |
648 while (p) { | |
649 if (p->encode != NULL && strcmp(name,p->name) == 0) | |
650 return p; | |
651 p = p->next; | |
652 } | |
653 return NULL; | |
654 } | |
655 | |
0 | 656 AVCodec *avcodec_find_decoder(enum CodecID id) |
657 { | |
658 AVCodec *p; | |
659 p = first_avcodec; | |
660 while (p) { | |
661 if (p->decode != NULL && p->id == id) | |
662 return p; | |
663 p = p->next; | |
664 } | |
665 return NULL; | |
666 } | |
667 | |
668 AVCodec *avcodec_find_decoder_by_name(const char *name) | |
669 { | |
670 AVCodec *p; | |
671 p = first_avcodec; | |
672 while (p) { | |
673 if (p->decode != NULL && strcmp(name,p->name) == 0) | |
674 return p; | |
675 p = p->next; | |
676 } | |
677 return NULL; | |
678 } | |
679 | |
2032
0817ee1f07e5
avcodec_find is in no header file, and appearently not used or very usefull so lets make it static ...
michael
parents:
2028
diff
changeset
|
680 static AVCodec *avcodec_find(enum CodecID id) |
0 | 681 { |
682 AVCodec *p; | |
683 p = first_avcodec; | |
684 while (p) { | |
685 if (p->id == id) | |
686 return p; | |
687 p = p->next; | |
688 } | |
689 return NULL; | |
690 } | |
691 | |
692 void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode) | |
693 { | |
694 const char *codec_name; | |
695 AVCodec *p; | |
696 char buf1[32]; | |
337 | 697 char channels_str[100]; |
92 | 698 int bitrate; |
0 | 699 |
700 if (encode) | |
701 p = avcodec_find_encoder(enc->codec_id); | |
702 else | |
703 p = avcodec_find_decoder(enc->codec_id); | |
704 | |
705 if (p) { | |
706 codec_name = p->name; | |
1449
7fbe89a76b73
update sub_id in mpegaudio decoding (might need same method as MPEG2VIDEO too ?)
bellard
parents:
1396
diff
changeset
|
707 if (!encode && enc->codec_id == CODEC_ID_MP3) { |
7fbe89a76b73
update sub_id in mpegaudio decoding (might need same method as MPEG2VIDEO too ?)
bellard
parents:
1396
diff
changeset
|
708 if (enc->sub_id == 2) |
7fbe89a76b73
update sub_id in mpegaudio decoding (might need same method as MPEG2VIDEO too ?)
bellard
parents:
1396
diff
changeset
|
709 codec_name = "mp2"; |
7fbe89a76b73
update sub_id in mpegaudio decoding (might need same method as MPEG2VIDEO too ?)
bellard
parents:
1396
diff
changeset
|
710 else if (enc->sub_id == 1) |
7fbe89a76b73
update sub_id in mpegaudio decoding (might need same method as MPEG2VIDEO too ?)
bellard
parents:
1396
diff
changeset
|
711 codec_name = "mp1"; |
7fbe89a76b73
update sub_id in mpegaudio decoding (might need same method as MPEG2VIDEO too ?)
bellard
parents:
1396
diff
changeset
|
712 } |
1582
ece0ad14a35d
added fake codec CODEC_ID_MPEG2TS of type CODEC_TYPE_DATA (needed for simpler handling of raw transport streams in ffserver and RTP - better solutions are welcomed)
bellard
parents:
1549
diff
changeset
|
713 } else if (enc->codec_id == CODEC_ID_MPEG2TS) { |
ece0ad14a35d
added fake codec CODEC_ID_MPEG2TS of type CODEC_TYPE_DATA (needed for simpler handling of raw transport streams in ffserver and RTP - better solutions are welcomed)
bellard
parents:
1549
diff
changeset
|
714 /* fake mpeg2 transport stream codec (currently not |
ece0ad14a35d
added fake codec CODEC_ID_MPEG2TS of type CODEC_TYPE_DATA (needed for simpler handling of raw transport streams in ffserver and RTP - better solutions are welcomed)
bellard
parents:
1549
diff
changeset
|
715 registered) */ |
ece0ad14a35d
added fake codec CODEC_ID_MPEG2TS of type CODEC_TYPE_DATA (needed for simpler handling of raw transport streams in ffserver and RTP - better solutions are welcomed)
bellard
parents:
1549
diff
changeset
|
716 codec_name = "mpeg2ts"; |
0 | 717 } else if (enc->codec_name[0] != '\0') { |
718 codec_name = enc->codec_name; | |
719 } else { | |
720 /* output avi tags */ | |
721 if (enc->codec_type == CODEC_TYPE_VIDEO) { | |
722 snprintf(buf1, sizeof(buf1), "%c%c%c%c", | |
723 enc->codec_tag & 0xff, | |
724 (enc->codec_tag >> 8) & 0xff, | |
725 (enc->codec_tag >> 16) & 0xff, | |
726 (enc->codec_tag >> 24) & 0xff); | |
727 } else { | |
728 snprintf(buf1, sizeof(buf1), "0x%04x", enc->codec_tag); | |
729 } | |
730 codec_name = buf1; | |
731 } | |
732 | |
733 switch(enc->codec_type) { | |
734 case CODEC_TYPE_VIDEO: | |
735 snprintf(buf, buf_size, | |
736 "Video: %s%s", | |
1389 | 737 codec_name, enc->mb_decision ? " (hq)" : ""); |
55 | 738 if (enc->codec_id == CODEC_ID_RAWVIDEO) { |
739 snprintf(buf + strlen(buf), buf_size - strlen(buf), | |
740 ", %s", | |
988
001b7d3045e5
moved avcodec_get_chroma_sub_sample() to imgconvert.c
bellard
parents:
963
diff
changeset
|
741 avcodec_get_pix_fmt_name(enc->pix_fmt)); |
55 | 742 } |
0 | 743 if (enc->width) { |
744 snprintf(buf + strlen(buf), buf_size - strlen(buf), | |
745 ", %dx%d, %0.2f fps", | |
746 enc->width, enc->height, | |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
747 (float)enc->frame_rate / enc->frame_rate_base); |
0 | 748 } |
741 | 749 if (encode) { |
750 snprintf(buf + strlen(buf), buf_size - strlen(buf), | |
751 ", q=%d-%d", enc->qmin, enc->qmax); | |
752 } | |
92 | 753 bitrate = enc->bit_rate; |
0 | 754 break; |
755 case CODEC_TYPE_AUDIO: | |
756 snprintf(buf, buf_size, | |
757 "Audio: %s", | |
758 codec_name); | |
318
21697f35a9ca
- Fixed AC3 decoding for 5:1 AC3 streams. Now when calling av_audio_decode for
pulento
parents:
315
diff
changeset
|
759 switch (enc->channels) { |
21697f35a9ca
- Fixed AC3 decoding for 5:1 AC3 streams. Now when calling av_audio_decode for
pulento
parents:
315
diff
changeset
|
760 case 1: |
337 | 761 strcpy(channels_str, "mono"); |
318
21697f35a9ca
- Fixed AC3 decoding for 5:1 AC3 streams. Now when calling av_audio_decode for
pulento
parents:
315
diff
changeset
|
762 break; |
21697f35a9ca
- Fixed AC3 decoding for 5:1 AC3 streams. Now when calling av_audio_decode for
pulento
parents:
315
diff
changeset
|
763 case 2: |
337 | 764 strcpy(channels_str, "stereo"); |
318
21697f35a9ca
- Fixed AC3 decoding for 5:1 AC3 streams. Now when calling av_audio_decode for
pulento
parents:
315
diff
changeset
|
765 break; |
21697f35a9ca
- Fixed AC3 decoding for 5:1 AC3 streams. Now when calling av_audio_decode for
pulento
parents:
315
diff
changeset
|
766 case 6: |
337 | 767 strcpy(channels_str, "5:1"); |
318
21697f35a9ca
- Fixed AC3 decoding for 5:1 AC3 streams. Now when calling av_audio_decode for
pulento
parents:
315
diff
changeset
|
768 break; |
21697f35a9ca
- Fixed AC3 decoding for 5:1 AC3 streams. Now when calling av_audio_decode for
pulento
parents:
315
diff
changeset
|
769 default: |
2423 | 770 snprintf(channels_str, sizeof(channels_str), "%d channels", enc->channels); |
318
21697f35a9ca
- Fixed AC3 decoding for 5:1 AC3 streams. Now when calling av_audio_decode for
pulento
parents:
315
diff
changeset
|
771 break; |
21697f35a9ca
- Fixed AC3 decoding for 5:1 AC3 streams. Now when calling av_audio_decode for
pulento
parents:
315
diff
changeset
|
772 } |
0 | 773 if (enc->sample_rate) { |
774 snprintf(buf + strlen(buf), buf_size - strlen(buf), | |
775 ", %d Hz, %s", | |
776 enc->sample_rate, | |
318
21697f35a9ca
- Fixed AC3 decoding for 5:1 AC3 streams. Now when calling av_audio_decode for
pulento
parents:
315
diff
changeset
|
777 channels_str); |
0 | 778 } |
318
21697f35a9ca
- Fixed AC3 decoding for 5:1 AC3 streams. Now when calling av_audio_decode for
pulento
parents:
315
diff
changeset
|
779 |
92 | 780 /* for PCM codecs, compute bitrate directly */ |
781 switch(enc->codec_id) { | |
782 case CODEC_ID_PCM_S16LE: | |
783 case CODEC_ID_PCM_S16BE: | |
784 case CODEC_ID_PCM_U16LE: | |
785 case CODEC_ID_PCM_U16BE: | |
94 | 786 bitrate = enc->sample_rate * enc->channels * 16; |
92 | 787 break; |
788 case CODEC_ID_PCM_S8: | |
789 case CODEC_ID_PCM_U8: | |
790 case CODEC_ID_PCM_ALAW: | |
791 case CODEC_ID_PCM_MULAW: | |
94 | 792 bitrate = enc->sample_rate * enc->channels * 8; |
92 | 793 break; |
794 default: | |
795 bitrate = enc->bit_rate; | |
796 break; | |
797 } | |
0 | 798 break; |
1582
ece0ad14a35d
added fake codec CODEC_ID_MPEG2TS of type CODEC_TYPE_DATA (needed for simpler handling of raw transport streams in ffserver and RTP - better solutions are welcomed)
bellard
parents:
1549
diff
changeset
|
799 case CODEC_TYPE_DATA: |
ece0ad14a35d
added fake codec CODEC_ID_MPEG2TS of type CODEC_TYPE_DATA (needed for simpler handling of raw transport streams in ffserver and RTP - better solutions are welcomed)
bellard
parents:
1549
diff
changeset
|
800 snprintf(buf, buf_size, "Data: %s", codec_name); |
ece0ad14a35d
added fake codec CODEC_ID_MPEG2TS of type CODEC_TYPE_DATA (needed for simpler handling of raw transport streams in ffserver and RTP - better solutions are welcomed)
bellard
parents:
1549
diff
changeset
|
801 bitrate = enc->bit_rate; |
ece0ad14a35d
added fake codec CODEC_ID_MPEG2TS of type CODEC_TYPE_DATA (needed for simpler handling of raw transport streams in ffserver and RTP - better solutions are welcomed)
bellard
parents:
1549
diff
changeset
|
802 break; |
0 | 803 default: |
2281 | 804 snprintf(buf, buf_size, "Invalid Codec type %d", enc->codec_type); |
805 return; | |
0 | 806 } |
741 | 807 if (encode) { |
808 if (enc->flags & CODEC_FLAG_PASS1) | |
809 snprintf(buf + strlen(buf), buf_size - strlen(buf), | |
810 ", pass 1"); | |
811 if (enc->flags & CODEC_FLAG_PASS2) | |
812 snprintf(buf + strlen(buf), buf_size - strlen(buf), | |
813 ", pass 2"); | |
814 } | |
92 | 815 if (bitrate != 0) { |
0 | 816 snprintf(buf + strlen(buf), buf_size - strlen(buf), |
92 | 817 ", %d kb/s", bitrate / 1000); |
0 | 818 } |
819 } | |
820 | |
362 | 821 unsigned avcodec_version( void ) |
822 { | |
823 return LIBAVCODEC_VERSION_INT; | |
824 } | |
55 | 825 |
379 | 826 unsigned avcodec_build( void ) |
827 { | |
828 return LIBAVCODEC_BUILD; | |
829 } | |
830 | |
0 | 831 /* must be called before any other functions */ |
832 void avcodec_init(void) | |
833 { | |
303
9a931fd8d06c
multiple init bugfix (patch by Alex Beregszaszi <alex@naxine.org>)
michaelni
parents:
267
diff
changeset
|
834 static int inited = 0; |
9a931fd8d06c
multiple init bugfix (patch by Alex Beregszaszi <alex@naxine.org>)
michaelni
parents:
267
diff
changeset
|
835 |
9a931fd8d06c
multiple init bugfix (patch by Alex Beregszaszi <alex@naxine.org>)
michaelni
parents:
267
diff
changeset
|
836 if (inited != 0) |
9a931fd8d06c
multiple init bugfix (patch by Alex Beregszaszi <alex@naxine.org>)
michaelni
parents:
267
diff
changeset
|
837 return; |
9a931fd8d06c
multiple init bugfix (patch by Alex Beregszaszi <alex@naxine.org>)
michaelni
parents:
267
diff
changeset
|
838 inited = 1; |
9a931fd8d06c
multiple init bugfix (patch by Alex Beregszaszi <alex@naxine.org>)
michaelni
parents:
267
diff
changeset
|
839 |
1201 | 840 dsputil_static_init(); |
0 | 841 } |
842 | |
1368 | 843 /** |
844 * Flush buffers, should be called when seeking or when swicthing to a different stream. | |
845 */ | |
341 | 846 void avcodec_flush_buffers(AVCodecContext *avctx) |
847 { | |
1368 | 848 if(avctx->codec->flush) |
849 avctx->codec->flush(avctx); | |
341 | 850 } |
851 | |
2231 | 852 void avcodec_default_free_buffers(AVCodecContext *s){ |
1214 | 853 int i, j; |
854 | |
855 if(s->internal_buffer==NULL) return; | |
856 | |
857 for(i=0; i<INTERNAL_BUFFER_SIZE; i++){ | |
858 InternalBuffer *buf= &((InternalBuffer*)s->internal_buffer)[i]; | |
859 for(j=0; j<4; j++){ | |
860 av_freep(&buf->base[j]); | |
861 buf->data[j]= NULL; | |
862 } | |
863 } | |
864 av_freep(&s->internal_buffer); | |
865 | |
866 s->internal_buffer_count=0; | |
867 } | |
868 | |
1264 | 869 char av_get_pict_type_char(int pict_type){ |
870 switch(pict_type){ | |
871 case I_TYPE: return 'I'; | |
872 case P_TYPE: return 'P'; | |
873 case B_TYPE: return 'B'; | |
874 case S_TYPE: return 'S'; | |
875 case SI_TYPE:return 'i'; | |
876 case SP_TYPE:return 'p'; | |
877 default: return '?'; | |
878 } | |
879 } | |
880 | |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
881 int av_reduce(int *dst_nom, int *dst_den, int64_t nom, int64_t den, int64_t max){ |
2125 | 882 AVRational a0={0,1}, a1={1,0}; |
883 int sign= (nom<0) ^ (den<0); | |
884 int64_t gcd= ff_gcd(ABS(nom), ABS(den)); | |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
885 |
2125 | 886 nom = ABS(nom)/gcd; |
887 den = ABS(den)/gcd; | |
888 if(nom<=max && den<=max){ | |
889 a1= (AVRational){nom, den}; | |
890 den=0; | |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
891 } |
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
892 |
2125 | 893 while(den){ |
894 int64_t x = nom / den; | |
895 int64_t next_den= nom - den*x; | |
896 int64_t a2n= x*a1.num + a0.num; | |
897 int64_t a2d= x*a1.den + a0.den; | |
898 | |
899 if(a2n > max || a2d > max) break; | |
900 | |
901 a0= a1; | |
902 a1= (AVRational){a2n, a2d}; | |
903 nom= den; | |
904 den= next_den; | |
905 } | |
906 assert(ff_gcd(a1.num, a1.den) == 1); | |
1549
5e643dd7e889
use continued fractions to approximate a fraction if its numerator or denominator is too large
michael
parents:
1548
diff
changeset
|
907 |
2125 | 908 *dst_nom = sign ? -a1.num : a1.num; |
909 *dst_den = a1.den; | |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
910 |
2125 | 911 return den==0; |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
912 } |
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
913 |
2242 | 914 int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd){ |
915 AVInteger ai; | |
916 int64_t r=0; | |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
917 assert(c > 0); |
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
918 assert(b >=0); |
2242 | 919 assert(rnd >=0 && rnd<=5 && rnd!=4); |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
920 |
2301 | 921 if(a<0 && a != INT64_MIN) return -av_rescale_rnd(-a, b, c, rnd ^ ((rnd>>1)&1)); |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
922 |
2242 | 923 if(rnd==AV_ROUND_NEAR_INF) r= c/2; |
924 else if(rnd&1) r= c-1; | |
925 | |
2002
b737b5e96ee0
use AVInteger in av_rescale() so it can finally do 64*64/64 instead of just 64*32/32
michael
parents:
1996
diff
changeset
|
926 if(b<=INT_MAX && c<=INT_MAX){ |
b737b5e96ee0
use AVInteger in av_rescale() so it can finally do 64*64/64 instead of just 64*32/32
michael
parents:
1996
diff
changeset
|
927 if(a<=INT_MAX) |
2242 | 928 return (a * b + r)/c; |
2002
b737b5e96ee0
use AVInteger in av_rescale() so it can finally do 64*64/64 instead of just 64*32/32
michael
parents:
1996
diff
changeset
|
929 else |
2242 | 930 return a/c*b + (a%c*b + r)/c; |
2002
b737b5e96ee0
use AVInteger in av_rescale() so it can finally do 64*64/64 instead of just 64*32/32
michael
parents:
1996
diff
changeset
|
931 } |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
932 |
2002
b737b5e96ee0
use AVInteger in av_rescale() so it can finally do 64*64/64 instead of just 64*32/32
michael
parents:
1996
diff
changeset
|
933 ai= av_mul_i(av_int2i(a), av_int2i(b)); |
2242 | 934 ai= av_add_i(ai, av_int2i(r)); |
2002
b737b5e96ee0
use AVInteger in av_rescale() so it can finally do 64*64/64 instead of just 64*32/32
michael
parents:
1996
diff
changeset
|
935 |
2242 | 936 return av_i2int(av_div_i(ai, av_int2i(c))); |
937 } | |
938 | |
939 int64_t av_rescale(int64_t a, int64_t b, int64_t c){ | |
940 return av_rescale_rnd(a, b, c, AV_ROUND_NEAR_INF); | |
1126
77ccf7fe3bd0
per context frame_rate_base, this should finally fix frame_rate related av sync issues
michaelni
parents:
1106
diff
changeset
|
941 } |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
942 |
2398
582e635cfa08
common.c -> bitstream.c (and the single non bitstream func -> utils.c)
michael
parents:
2370
diff
changeset
|
943 int64_t ff_gcd(int64_t a, int64_t b){ |
582e635cfa08
common.c -> bitstream.c (and the single non bitstream func -> utils.c)
michael
parents:
2370
diff
changeset
|
944 if(b) return ff_gcd(b, a%b); |
582e635cfa08
common.c -> bitstream.c (and the single non bitstream func -> utils.c)
michael
parents:
2370
diff
changeset
|
945 else return a; |
582e635cfa08
common.c -> bitstream.c (and the single non bitstream func -> utils.c)
michael
parents:
2370
diff
changeset
|
946 } |
582e635cfa08
common.c -> bitstream.c (and the single non bitstream func -> utils.c)
michael
parents:
2370
diff
changeset
|
947 |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
948 /* av_log API */ |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
949 |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
950 static int av_log_level = AV_LOG_DEBUG; |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
951 |
1855
bafde44145f9
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1854
diff
changeset
|
952 static void av_log_default_callback(void* ptr, int level, const char* fmt, va_list vl) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
953 { |
1600 | 954 static int print_prefix=1; |
1856 | 955 AVClass* avc= ptr ? *(AVClass**)ptr : NULL; |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
956 if(level>av_log_level) |
1855
bafde44145f9
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1854
diff
changeset
|
957 return; |
1823
a660ef952580
(f)printf() is disallowed in libavcodec, compilation will fail now if its used, except that codecs which where added after the printf->av_log change which did ignore av_log() and used prinf are now silent and wont print anything, they should be changed to use av_log, i could do that, but its better if the orginal developer decides which AV_LOG level each message should get
michael
parents:
1799
diff
changeset
|
958 #undef fprintf |
1856 | 959 if(print_prefix && avc) { |
960 fprintf(stderr, "[%s @ %p]", avc->item_name(ptr), avc); | |
1855
bafde44145f9
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1854
diff
changeset
|
961 } |
1823
a660ef952580
(f)printf() is disallowed in libavcodec, compilation will fail now if its used, except that codecs which where added after the printf->av_log change which did ignore av_log() and used prinf are now silent and wont print anything, they should be changed to use av_log, i could do that, but its better if the orginal developer decides which AV_LOG level each message should get
michael
parents:
1799
diff
changeset
|
962 #define fprintf please_use_av_log |
1600 | 963 |
1776 | 964 print_prefix= strstr(fmt, "\n") != NULL; |
1600 | 965 |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
966 vfprintf(stderr, fmt, vl); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
967 } |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
968 |
1855
bafde44145f9
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1854
diff
changeset
|
969 static void (*av_log_callback)(void*, int, const char*, va_list) = av_log_default_callback; |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
970 |
1855
bafde44145f9
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1854
diff
changeset
|
971 void av_log(void* avcl, int level, const char *fmt, ...) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
972 { |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
973 va_list vl; |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
974 va_start(vl, fmt); |
1855
bafde44145f9
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1854
diff
changeset
|
975 av_vlog(avcl, level, fmt, vl); |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
976 va_end(vl); |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
977 } |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
978 |
1855
bafde44145f9
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1854
diff
changeset
|
979 void av_vlog(void* avcl, int level, const char *fmt, va_list vl) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
980 { |
1855
bafde44145f9
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1854
diff
changeset
|
981 av_log_callback(avcl, level, fmt, vl); |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
982 } |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
983 |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
984 int av_log_get_level(void) |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
985 { |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
986 return av_log_level; |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
987 } |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
988 |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
989 void av_log_set_level(int level) |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
990 { |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
991 av_log_level = level; |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
992 } |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
993 |
1855
bafde44145f9
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1854
diff
changeset
|
994 void av_log_set_callback(void (*callback)(void*, int, const char*, va_list)) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
995 { |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
996 av_log_callback = callback; |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
997 } |
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1588
diff
changeset
|
998 |
2362
7a6ff8cc7c95
BeOS threading support. changed some "if FOO_THREAD||BAR_THREAD" to a more generic "if HAVE_THREADS"
mmu_man
parents:
2324
diff
changeset
|
999 #if !defined(HAVE_THREADS) |
2013
85e547a18d87
dummy avcodec_thread_init() to avoid linking issues
michael
parents:
2002
diff
changeset
|
1000 int avcodec_thread_init(AVCodecContext *s, int thread_count){ |
85e547a18d87
dummy avcodec_thread_init() to avoid linking issues
michael
parents:
2002
diff
changeset
|
1001 return -1; |
85e547a18d87
dummy avcodec_thread_init() to avoid linking issues
michael
parents:
2002
diff
changeset
|
1002 } |
85e547a18d87
dummy avcodec_thread_init() to avoid linking issues
michael
parents:
2002
diff
changeset
|
1003 #endif |