de6d9b64 |
/*
* utils for libavcodec |
406792e7 |
* Copyright (c) 2001 Fabrice Bellard |
8f2ab833 |
* Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at> |
de6d9b64 |
* |
b78e7197 |
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or |
ff4ec49e |
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either |
b78e7197 |
* version 2.1 of the License, or (at your option) any later version. |
de6d9b64 |
* |
b78e7197 |
* FFmpeg is distributed in the hope that it will be useful, |
de6d9b64 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
ff4ec49e |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details. |
de6d9b64 |
* |
ff4ec49e |
* You should have received a copy of the GNU Lesser General Public |
b78e7197 |
* License along with FFmpeg; if not, write to the Free Software |
5509bffa |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
de6d9b64 |
*/ |
115329f1 |
|
983e3246 |
/** |
ba87f080 |
* @file |
983e3246 |
* utils.
*/ |
115329f1 |
|
7fb94406 |
#include "libavutil/avstring.h" |
245976da |
#include "libavutil/integer.h"
#include "libavutil/crc.h" |
eb285cfe |
#include "libavutil/pixdesc.h" |
7ffe76e5 |
#include "libavutil/audioconvert.h"
#include "libavutil/imgutils.h"
#include "libavutil/samplefmt.h" |
47953c33 |
#include "libavutil/dict.h" |
de6d9b64 |
#include "avcodec.h" |
3123dd79 |
#include "dsputil.h" |
6ed04040 |
#include "libavutil/opt.h" |
db7ae7d1 |
#include "imgconvert.h" |
b38f008e |
#include "thread.h" |
9e82a113 |
#include "audioconvert.h" |
0ba39dd1 |
#include "internal.h" |
7246177d |
#include <stdlib.h> |
9b879566 |
#include <stdarg.h> |
4c263142 |
#include <limits.h> |
860a40c8 |
#include <float.h> |
de6d9b64 |
|
ddebfb15 |
static int volatile entangled_thread_counter=0; |
291f326a |
static int (*ff_lockmgr_cb)(void **mutex, enum AVLockOp op); |
f988ce6c |
static void *codec_mutex; |
ddebfb15 |
|
372c3f82 |
void *av_fast_realloc(void *ptr, unsigned int *size, FF_INTERNALC_MEM_TYPE min_size) |
8e1e6f31 |
{ |
115329f1 |
if(min_size < *size) |
8e1e6f31 |
return ptr; |
115329f1 |
|
372c3f82 |
min_size= FFMAX(17*min_size/16 + 32, min_size); |
8e1e6f31 |
|
372c3f82 |
ptr= av_realloc(ptr, min_size); |
978805b2 |
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 |
372c3f82 |
min_size= 0;
*size= min_size; |
978805b2 |
return ptr; |
8e1e6f31 |
}
|
372c3f82 |
void av_fast_malloc(void *ptr, unsigned int *size, FF_INTERNALC_MEM_TYPE min_size) |
238ef6da |
{
void **p = ptr;
if (min_size < *size)
return; |
372c3f82 |
min_size= FFMAX(17*min_size/16 + 32, min_size); |
238ef6da |
av_free(*p); |
372c3f82 |
*p = av_malloc(min_size);
if (!*p) min_size = 0;
*size= min_size; |
238ef6da |
}
|
de6d9b64 |
/* encoder management */ |
e6df765e |
static AVCodec *first_avcodec = NULL; |
de6d9b64 |
|
55b9e69a |
AVCodec *av_codec_next(AVCodec *c){
if(c) return c->next;
else return first_avcodec;
}
|
85662f49 |
void avcodec_register(AVCodec *codec) |
de6d9b64 |
{
AVCodec **p; |
7a961a46 |
avcodec_init(); |
de6d9b64 |
p = &first_avcodec;
while (*p != NULL) p = &(*p)->next; |
335a761a |
*p = codec;
codec->next = NULL; |
de6d9b64 |
}
|
9d385cfe |
#if LIBAVCODEC_VERSION_MAJOR < 53 |
85662f49 |
void register_avcodec(AVCodec *codec)
{
avcodec_register(codec);
} |
9d385cfe |
#endif |
85662f49 |
|
0fb49b59 |
unsigned avcodec_get_edge_width(void)
{
return EDGE_WIDTH;
}
|
21adafec |
void avcodec_set_dimensions(AVCodecContext *s, int width, int height){
s->coded_width = width;
s->coded_height= height;
s->width = -((-width )>>s->lowres);
s->height= -((-height)>>s->lowres);
}
|
d90cf87b |
typedef struct InternalBuffer{ |
1e491e29 |
int last_pic_num; |
d90cf87b |
uint8_t *base[4]; |
1e491e29 |
uint8_t *data[4]; |
237e4938 |
int linesize[4]; |
0701006e |
int width, height;
enum PixelFormat pix_fmt; |
d90cf87b |
}InternalBuffer;
|
6a9c8594 |
#define INTERNAL_BUFFER_SIZE (32+1) |
1e491e29 |
|
eb285cfe |
void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height, int linesize_align[4]){ |
115329f1 |
int w_align= 1;
int h_align= 1;
|
f0bbfc4a |
switch(s->pix_fmt){
case PIX_FMT_YUV420P: |
71e445fc |
case PIX_FMT_YUYV422: |
ebb177dd |
case PIX_FMT_UYVY422: |
f0bbfc4a |
case PIX_FMT_YUV422P: |
98c82d69 |
case PIX_FMT_YUV440P: |
f0bbfc4a |
case PIX_FMT_YUV444P:
case PIX_FMT_GRAY8: |
34380af0 |
case PIX_FMT_GRAY16BE:
case PIX_FMT_GRAY16LE: |
f0bbfc4a |
case PIX_FMT_YUVJ420P:
case PIX_FMT_YUVJ422P: |
98c82d69 |
case PIX_FMT_YUVJ440P: |
f0bbfc4a |
case PIX_FMT_YUVJ444P: |
b70335a2 |
case PIX_FMT_YUVA420P: |
d4497f6d |
case PIX_FMT_YUV420P9LE:
case PIX_FMT_YUV420P9BE:
case PIX_FMT_YUV420P10LE:
case PIX_FMT_YUV420P10BE: |
299cbe2c |
case PIX_FMT_YUV422P10LE:
case PIX_FMT_YUV422P10BE: |
87eedf69 |
case PIX_FMT_YUV444P9LE:
case PIX_FMT_YUV444P9BE:
case PIX_FMT_YUV444P10LE:
case PIX_FMT_YUV444P10BE: |
f0bbfc4a |
w_align= 16; //FIXME check for non mpeg style codecs and use less alignment
h_align= 16; |
00d1e96b |
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 || s->codec_id == CODEC_ID_H264) |
c81185a1 |
h_align= 32; // interlaced is rounded up to 2 MBs |
f0bbfc4a |
break;
case PIX_FMT_YUV411P: |
71e445fc |
case PIX_FMT_UYYVYY411: |
f0bbfc4a |
w_align=32;
h_align=8;
break;
case PIX_FMT_YUV410P:
if(s->codec_id == CODEC_ID_SVQ1){
w_align=64;
h_align=64;
} |
d99fbbf4 |
case PIX_FMT_RGB555:
if(s->codec_id == CODEC_ID_RPZA){
w_align=4;
h_align=4;
}
case PIX_FMT_PAL8: |
6337178b |
case PIX_FMT_BGR8:
case PIX_FMT_RGB8: |
d99fbbf4 |
if(s->codec_id == CODEC_ID_SMC){
w_align=4;
h_align=4;
} |
f0bbfc4a |
break; |
c31b8121 |
case PIX_FMT_BGR24:
if((s->codec_id == CODEC_ID_MSZH) || (s->codec_id == CODEC_ID_ZLIB)){
w_align=4;
h_align=4;
}
break; |
f0bbfc4a |
default:
w_align= 1;
h_align= 1;
break;
}
|
ef516f73 |
*width = FFALIGN(*width , w_align);
*height= FFALIGN(*height, h_align); |
ba68d9d3 |
if(s->codec_id == CODEC_ID_H264 || s->lowres) |
ae4ffe9f |
*height+=2; // some of the optimized chroma MC reads one line too much |
ba68d9d3 |
// which is also done in mpeg decoders with lowres > 0 |
eb285cfe |
linesize_align[0] =
linesize_align[1] =
linesize_align[2] =
linesize_align[3] = STRIDE_ALIGN;
//STRIDE_ALIGN is 8 for SSE* but this does not work for SVQ1 chroma planes
//we could change STRIDE_ALIGN to 16 for x86/sse but it would increase the
//picture size unneccessarily in some cases. The solution here is not
//pretty and better ideas are welcome!
#if HAVE_MMX
if(s->codec_id == CODEC_ID_SVQ1 || s->codec_id == CODEC_ID_VP5 ||
s->codec_id == CODEC_ID_VP6 || s->codec_id == CODEC_ID_VP6F ||
s->codec_id == CODEC_ID_VP6A) {
linesize_align[0] =
linesize_align[1] =
linesize_align[2] = 16;
}
#endif
}
void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height){
int chroma_shift = av_pix_fmt_descriptors[s->pix_fmt].log2_chroma_w;
int linesize_align[4];
int align;
avcodec_align_dimensions2(s, width, height, linesize_align);
align = FFMAX(linesize_align[0], linesize_align[3]);
linesize_align[1] <<= chroma_shift;
linesize_align[2] <<= chroma_shift;
align = FFMAX3(align, linesize_align[1], linesize_align[2]);
*width=FFALIGN(*width, align); |
f0bbfc4a |
}
|
bf176f58 |
#if LIBAVCODEC_VERSION_MAJOR < 53 |
0ecca7a4 |
int avcodec_check_dimensions(void *av_log_ctx, unsigned int w, unsigned int h){ |
e16f217c |
return av_image_check_size(w, h, 0, av_log_ctx); |
0ecca7a4 |
} |
bf176f58 |
#endif |
0ecca7a4 |
|
492cd3a9 |
int avcodec_default_get_buffer(AVCodecContext *s, AVFrame *pic){ |
1e491e29 |
int i; |
f0bbfc4a |
int w= s->width;
int h= s->height; |
d90cf87b |
InternalBuffer *buf; |
237e4938 |
int *picture_number; |
0ecca7a4 |
|
65d999d6 |
if(pic->data[0]!=NULL) {
av_log(s, AV_LOG_ERROR, "pic->data[0]!=NULL in avcodec_default_get_buffer\n");
return -1;
}
if(s->internal_buffer_count >= INTERNAL_BUFFER_SIZE) {
av_log(s, AV_LOG_ERROR, "internal_buffer_count overflow (missing release_buffer?)\n");
return -1;
} |
1e491e29 |
|
e16f217c |
if(av_image_check_size(w, h, 0, s)) |
0ecca7a4 |
return -1;
|
d90cf87b |
if(s->internal_buffer==NULL){ |
6ebc89ac |
s->internal_buffer= av_mallocz((INTERNAL_BUFFER_SIZE+1)*sizeof(InternalBuffer)); |
d90cf87b |
}
#if 0
s->internal_buffer= av_fast_realloc( |
115329f1 |
s->internal_buffer,
&s->internal_buffer_size, |
d90cf87b |
sizeof(InternalBuffer)*FFMAX(99, s->internal_buffer_count+1)/*FIXME*/
);
#endif |
115329f1 |
|
d90cf87b |
buf= &((InternalBuffer*)s->internal_buffer)[s->internal_buffer_count]; |
6ebc89ac |
picture_number= &(((InternalBuffer*)s->internal_buffer)[INTERNAL_BUFFER_SIZE]).last_pic_num; //FIXME ugly hack |
237e4938 |
(*picture_number)++; |
115329f1 |
|
0701006e |
if(buf->base[0] && (buf->width != w || buf->height != h || buf->pix_fmt != s->pix_fmt)){ |
b38f008e |
if(s->active_thread_type&FF_THREAD_FRAME) {
av_log_missing_feature(s, "Width/height changing with frame threads is", 0);
return -1;
}
|
0701006e |
for(i=0; i<4; i++){
av_freep(&buf->base[i]);
buf->data[i]= NULL;
}
}
|
d90cf87b |
if(buf->base[0]){ |
237e4938 |
pic->age= *picture_number - buf->last_pic_num;
buf->last_pic_num= *picture_number; |
1e491e29 |
}else{ |
f0bbfc4a |
int h_chroma_shift, v_chroma_shift; |
db7ae7d1 |
int size[4] = {0};
int tmpsize; |
c9d6e847 |
int unaligned; |
c7622f9a |
AVPicture picture; |
503bc402 |
int stride_align[4]; |
dc172ecc |
const int pixel_size = av_pix_fmt_descriptors[s->pix_fmt].comp[0].step_minus1+1; |
c7622f9a |
|
1e491e29 |
avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift); |
f0bbfc4a |
|
eb285cfe |
avcodec_align_dimensions2(s, &w, &h, stride_align); |
115329f1 |
|
1e491e29 |
if(!(s->flags&CODEC_FLAG_EMU_EDGE)){
w+= EDGE_WIDTH*2;
h+= EDGE_WIDTH*2;
} |
5b67307a |
|
c9d6e847 |
do {
// NOTE: do not align linesizes individually, this breaks e.g. assumptions
// that linesize[0] == 2*linesize[1] in the MPEG-encoder for 4:2:2 |
9d2e0ad8 |
av_image_fill_linesizes(picture.linesize, s->pix_fmt, w); |
c9d6e847 |
// increase alignment of w for next try (rhs gives the lowest bit set in w)
w += w & ~(w-1); |
db7ae7d1 |
|
c9d6e847 |
unaligned = 0; |
45bae968 |
for (i=0; i<4; i++){ |
c9d6e847 |
unaligned |= picture.linesize[i] % stride_align[i]; |
45bae968 |
} |
c9d6e847 |
} while (unaligned); |
db7ae7d1 |
|
9d2e0ad8 |
tmpsize = av_image_fill_pointers(picture.data, s->pix_fmt, h, NULL, picture.linesize); |
f8c96d01 |
if (tmpsize < 0)
return -1; |
db7ae7d1 |
for (i=0; i<3 && picture.data[i+1]; i++)
size[i] = picture.data[i+1] - picture.data[i]; |
cf73e32a |
size[i] = tmpsize - (picture.data[i] - picture.data[0]); |
c7622f9a |
|
d90cf87b |
buf->last_pic_num= -256*256*256*64; |
c7622f9a |
memset(buf->base, 0, sizeof(buf->base));
memset(buf->data, 0, sizeof(buf->data)); |
1e491e29 |
|
b70335a2 |
for(i=0; i<4 && size[i]; i++){ |
2c19981a |
const int h_shift= i==0 ? 0 : h_chroma_shift;
const int v_shift= i==0 ? 0 : v_chroma_shift; |
1e491e29 |
|
c7622f9a |
buf->linesize[i]= picture.linesize[i]; |
1e491e29 |
|
c7622f9a |
buf->base[i]= av_malloc(size[i]+16); //FIXME 16 |
d90cf87b |
if(buf->base[i]==NULL) return -1; |
c7622f9a |
memset(buf->base[i], 128, size[i]);
|
3491a9b2 |
// no edge if EDGE EMU or not planar YUV |
6337178b |
if((s->flags&CODEC_FLAG_EMU_EDGE) || !size[2]) |
d90cf87b |
buf->data[i] = buf->base[i]; |
1e491e29 |
else |
dc172ecc |
buf->data[i] = buf->base[i] + FFALIGN((buf->linesize[i]*EDGE_WIDTH>>v_shift) + (pixel_size*EDGE_WIDTH>>h_shift), stride_align[i]); |
1e491e29 |
} |
6337178b |
if(size[1] && !size[2]) |
ed5d30d9 |
ff_set_systematic_pal2((uint32_t*)buf->data[1], s->pix_fmt); |
0701006e |
buf->width = s->width;
buf->height = s->height;
buf->pix_fmt= s->pix_fmt; |
1e491e29 |
pic->age= 256*256*256*64;
} |
237e4938 |
pic->type= FF_BUFFER_TYPE_INTERNAL; |
1e491e29 |
|
d90cf87b |
for(i=0; i<4; i++){
pic->base[i]= buf->base[i];
pic->data[i]= buf->data[i]; |
237e4938 |
pic->linesize[i]= buf->linesize[i]; |
d90cf87b |
}
s->internal_buffer_count++;
|
1ba57272 |
if (s->pkt) {
pic->pkt_pts = s->pkt->pts;
pic->pkt_pos = s->pkt->pos;
} else {
pic->pkt_pts = AV_NOPTS_VALUE;
pic->pkt_pos = -1;
} |
79de84f2 |
pic->reordered_opaque= s->reordered_opaque; |
a3bc7a9e |
pic->sample_aspect_ratio = s->sample_aspect_ratio;
pic->width = s->width;
pic->height = s->height;
pic->format = s->pix_fmt; |
79de84f2 |
|
385c820b |
if(s->debug&FF_DEBUG_BUFFERS)
av_log(s, AV_LOG_DEBUG, "default_get_buffer called on pic %p, %d buffers used\n", pic, s->internal_buffer_count);
|
1e491e29 |
return 0;
}
|
492cd3a9 |
void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic){ |
1e491e29 |
int i; |
6829ac8d |
InternalBuffer *buf, *last; |
d90cf87b |
|
4e00e76b |
assert(pic->type==FF_BUFFER_TYPE_INTERNAL); |
59c673d5 |
assert(s->internal_buffer_count); |
d90cf87b |
|
d375c104 |
if(s->internal_buffer){ |
b1609412 |
buf = NULL; /* avoids warning */ |
d90cf87b |
for(i=0; i<s->internal_buffer_count; i++){ //just 3-5 checks so is not worth to optimize
buf= &((InternalBuffer*)s->internal_buffer)[i];
if(buf->data[0] == pic->data[0])
break;
}
assert(i < s->internal_buffer_count);
s->internal_buffer_count--;
last = &((InternalBuffer*)s->internal_buffer)[s->internal_buffer_count];
|
6829ac8d |
FFSWAP(InternalBuffer, *buf, *last); |
d375c104 |
} |
d90cf87b |
|
b70335a2 |
for(i=0; i<4; i++){ |
1e491e29 |
pic->data[i]=NULL; |
d90cf87b |
// pic->base[i]=NULL;
} |
1e491e29 |
//printf("R%X\n", pic->opaque); |
385c820b |
if(s->debug&FF_DEBUG_BUFFERS)
av_log(s, AV_LOG_DEBUG, "default_release_buffer called on pic %p, %d buffers used\n", pic, s->internal_buffer_count); |
1e491e29 |
}
|
e1c2a5a0 |
int avcodec_default_reget_buffer(AVCodecContext *s, AVFrame *pic){
AVFrame temp_pic;
int i;
/* If no picture return a new buffer */
if(pic->data[0] == NULL) {
/* We will copy from buffer, so must be readable */
pic->buffer_hints |= FF_BUFFER_HINTS_READABLE;
return s->get_buffer(s, pic);
}
/* If internal buffer type return the same buffer */ |
b8af4fe9 |
if(pic->type == FF_BUFFER_TYPE_INTERNAL) { |
cf96cce7 |
if(s->pkt) pic->pkt_pts= s->pkt->pts;
else pic->pkt_pts= AV_NOPTS_VALUE; |
b8af4fe9 |
pic->reordered_opaque= s->reordered_opaque; |
e1c2a5a0 |
return 0; |
b8af4fe9 |
} |
e1c2a5a0 |
/*
* Not internal type and reget_buffer not overridden, emulate cr buffer
*/
temp_pic = *pic;
for(i = 0; i < 4; i++)
pic->data[i] = pic->base[i] = NULL;
pic->opaque = NULL;
/* Allocate new frame */
if (s->get_buffer(s, pic))
return -1;
/* Copy image data from old buffer to new buffer */ |
636d6a4a |
av_picture_copy((AVPicture*)pic, (AVPicture*)&temp_pic, s->pix_fmt, s->width, |
e1c2a5a0 |
s->height);
s->release_buffer(s, &temp_pic); // Release old frame
return 0;
}
|
3a84713a |
int avcodec_default_execute(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2),void *arg, int *ret, int count, int size){ |
9c3d33d6 |
int i;
for(i=0; i<count; i++){ |
3a84713a |
int r= func(c, (char*)arg + i*size); |
9c3d33d6 |
if(ret) ret[i]= r;
}
return 0;
}
|
8d23a86f |
int avcodec_default_execute2(AVCodecContext *c, int (*func)(AVCodecContext *c2, void *arg2, int jobnr, int threadnr),void *arg, int *ret, int count){
int i;
for(i=0; i<count; i++){
int r= func(c, arg, i, 0);
if(ret) ret[i]= r;
}
return 0;
}
|
c269cf68 |
enum PixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum PixelFormat *fmt){
while (*fmt != PIX_FMT_NONE && ff_is_hwaccel_pix_fmt(*fmt))
++fmt; |
a33c7159 |
return fmt[0];
}
|
9740beff |
void avcodec_get_frame_defaults(AVFrame *pic){
memset(pic, 0, sizeof(AVFrame));
|
76ad67ca |
pic->pts = pic->best_effort_timestamp = AV_NOPTS_VALUE; |
1ba57272 |
pic->pkt_pos = -1; |
c342499d |
pic->key_frame= 1; |
77e9dee8 |
pic->sample_aspect_ratio = (AVRational){0, 1}; |
18ded93a |
pic->format = -1; /* unknown */ |
9740beff |
}
|
492cd3a9 |
AVFrame *avcodec_alloc_frame(void){ |
9740beff |
AVFrame *pic= av_malloc(sizeof(AVFrame)); |
115329f1 |
|
9740beff |
if(pic==NULL) return NULL; |
115329f1 |
|
9740beff |
avcodec_get_frame_defaults(pic); |
115329f1 |
|
1e491e29 |
return pic;
}
|
3ee8ca9b |
static void avcodec_get_subtitle_defaults(AVSubtitle *sub)
{
memset(sub, 0, sizeof(*sub));
sub->pts = AV_NOPTS_VALUE;
}
|
47953c33 |
#if FF_API_AVCODEC_OPEN |
5e4c7ca2 |
int attribute_align_arg avcodec_open(AVCodecContext *avctx, AVCodec *codec) |
de6d9b64 |
{ |
47953c33 |
return avcodec_open2(avctx, codec, NULL);
}
#endif
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, AVCodec *codec, AVDictionary **options)
{ |
31d76ec2 |
int ret = 0; |
47953c33 |
AVDictionary *tmp = NULL;
if (options)
av_dict_copy(&tmp, *options, 0); |
115329f1 |
|
f988ce6c |
/* If there is a user-supplied mutex locking routine, call it. */
if (ff_lockmgr_cb) {
if ((*ff_lockmgr_cb)(&codec_mutex, AV_LOCK_OBTAIN))
return -1;
}
|
ddebfb15 |
entangled_thread_counter++;
if(entangled_thread_counter != 1){
av_log(avctx, AV_LOG_ERROR, "insufficient thread locking around avcodec_open/close()\n"); |
31d76ec2 |
ret = -1; |
ddebfb15 |
goto end;
} |
de6d9b64 |
|
31d76ec2 |
if(avctx->codec || !codec) {
ret = AVERROR(EINVAL); |
ddebfb15 |
goto end; |
31d76ec2 |
} |
09770af8 |
|
0edf8a7a |
if (codec->priv_data_size > 0) { |
dc51a72b |
if(!avctx->priv_data){ |
0edf8a7a |
avctx->priv_data = av_mallocz(codec->priv_data_size); |
90f06cea |
if (!avctx->priv_data) {
ret = AVERROR(ENOMEM); |
ddebfb15 |
goto end; |
90f06cea |
} |
47953c33 |
if (codec->priv_class) { |
dc51a72b |
*(AVClass**)avctx->priv_data= codec->priv_class;
av_opt_set_defaults(avctx->priv_data);
}
} |
23f0d0f1 |
if (codec->priv_class && (ret = av_opt_set_dict(avctx->priv_data, &tmp)) < 0) |
47953c33 |
goto free_and_end; |
0edf8a7a |
} else {
avctx->priv_data = NULL;
} |
47953c33 |
if ((ret = av_opt_set_dict(avctx, &tmp)) < 0)
goto free_and_end; |
21adafec |
if(avctx->coded_width && avctx->coded_height)
avcodec_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);
else if(avctx->width && avctx->height)
avcodec_set_dimensions(avctx, avctx->width, avctx->height);
|
82eac2f3 |
if ((avctx->coded_width || avctx->coded_height || avctx->width || avctx->height)
&& ( av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx) < 0
|| av_image_check_size(avctx->width, avctx->height, 0, avctx) < 0)) {
av_log(avctx, AV_LOG_WARNING, "ignoring invalid width/height values\n");
avcodec_set_dimensions(avctx, 0, 0);
}
|
f19c58b4 |
/* if the decoder init function was already called previously,
free the already allocated subtitle_header before overwriting it */
if (codec->decode)
av_freep(&avctx->subtitle_header);
|
fa77dd63 |
#define SANE_NB_CHANNELS 128U |
82eac2f3 |
if (avctx->channels > SANE_NB_CHANNELS) { |
7868349a |
ret = AVERROR(EINVAL); |
2a9b5c9b |
goto free_and_end; |
0ecca7a4 |
}
|
b5c85991 |
avctx->codec = codec; |
72415b2a |
if ((avctx->codec_type == AVMEDIA_TYPE_UNKNOWN || avctx->codec_type == codec->type) && |
681c180d |
avctx->codec_id == CODEC_ID_NONE) {
avctx->codec_type = codec->type;
avctx->codec_id = codec->id;
} |
e83c716e |
if (avctx->codec_id != codec->id || (avctx->codec_type != codec->type
&& avctx->codec_type != AVMEDIA_TYPE_ATTACHMENT)) { |
4c0dda2b |
av_log(avctx, AV_LOG_ERROR, "codec type or id mismatches\n"); |
31d76ec2 |
ret = AVERROR(EINVAL); |
2a9b5c9b |
goto free_and_end; |
4c0dda2b |
} |
b5c85991 |
avctx->frame_number = 0; |
b38f008e |
if (HAVE_THREADS && !avctx->thread_opaque) { |
46027c72 |
ret = ff_thread_init(avctx); |
b38f008e |
if (ret < 0) {
goto free_and_end;
}
}
|
7a54edaa |
if (avctx->codec->max_lowres < avctx->lowres || avctx->lowres < 0) { |
527c91e3 |
av_log(avctx, AV_LOG_ERROR, "The maximum value for lowres supported by the decoder is %d\n",
avctx->codec->max_lowres); |
31d76ec2 |
ret = AVERROR(EINVAL); |
527c91e3 |
goto free_and_end;
} |
8b00ab01 |
if (avctx->codec->encode) { |
7ade06cc |
int i; |
8b00ab01 |
if (avctx->codec->sample_fmts) { |
dcf1830a |
if (avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
avctx->sample_fmt = AV_SAMPLE_FMT_S16; |
3dfc3e70 |
for (i = 0; avctx->codec->sample_fmts[i] != AV_SAMPLE_FMT_NONE; i++)
if (avctx->sample_fmt == avctx->codec->sample_fmts[i])
break;
if (avctx->codec->sample_fmts[i] == AV_SAMPLE_FMT_NONE) {
av_log(avctx, AV_LOG_ERROR, "Specified sample_fmt is not supported.\n");
ret = AVERROR(EINVAL);
goto free_and_end;
} |
8b00ab01 |
}
if (avctx->codec->supported_samplerates) {
for (i = 0; avctx->codec->supported_samplerates[i] != 0; i++)
if (avctx->sample_rate == avctx->codec->supported_samplerates[i])
break;
if (avctx->codec->supported_samplerates[i] == 0) {
av_log(avctx, AV_LOG_ERROR, "Specified sample_rate is not supported\n");
ret = AVERROR(EINVAL);
goto free_and_end;
}
}
if (avctx->codec->channel_layouts) {
if (!avctx->channel_layout) {
av_log(avctx, AV_LOG_WARNING, "channel_layout not specified\n");
} else {
for (i = 0; avctx->codec->channel_layouts[i] != 0; i++)
if (avctx->channel_layout == avctx->codec->channel_layouts[i])
break;
if (avctx->codec->channel_layouts[i] == 0) {
av_log(avctx, AV_LOG_ERROR, "Specified channel_layout is not supported\n");
ret = AVERROR(EINVAL);
goto free_and_end;
}
}
} |
168f9e8c |
if (avctx->channel_layout && avctx->channels) {
if (av_get_channel_layout_nb_channels(avctx->channel_layout) != avctx->channels) {
av_log(avctx, AV_LOG_ERROR, "channel layout does not match number of channels\n");
ret = AVERROR(EINVAL);
goto free_and_end;
} |
688b09fa |
} else if (avctx->channel_layout) {
avctx->channels = av_get_channel_layout_nb_channels(avctx->channel_layout); |
7ade06cc |
}
} |
0fd0ef79 |
|
76ad67ca |
avctx->pts_correction_num_faulty_pts =
avctx->pts_correction_num_faulty_dts = 0;
avctx->pts_correction_last_pts =
avctx->pts_correction_last_dts = INT64_MIN;
|
b38f008e |
if(avctx->codec->init && !(avctx->active_thread_type&FF_THREAD_FRAME)){ |
2de4f9eb |
ret = avctx->codec->init(avctx);
if (ret < 0) { |
2a9b5c9b |
goto free_and_end; |
2de4f9eb |
} |
6e546aaa |
} |
d375c104 |
|
ddebfb15 |
ret=0;
end:
entangled_thread_counter--; |
f988ce6c |
/* Release any user-supplied mutex. */
if (ff_lockmgr_cb) {
(*ff_lockmgr_cb)(&codec_mutex, AV_LOCK_RELEASE);
} |
47953c33 |
if (options) {
av_dict_free(options);
*options = tmp;
}
|
ddebfb15 |
return ret; |
2a9b5c9b |
free_and_end: |
47953c33 |
av_dict_free(&tmp); |
2a9b5c9b |
av_freep(&avctx->priv_data);
avctx->codec= NULL;
goto end; |
de6d9b64 |
}
|
5e4c7ca2 |
int attribute_align_arg avcodec_encode_audio(AVCodecContext *avctx, uint8_t *buf, int buf_size, |
de6d9b64 |
const short *samples)
{ |
0ecca7a4 |
if(buf_size < FF_MIN_BUFFER_SIZE && 0){ |
5286d11f |
av_log(avctx, AV_LOG_ERROR, "buffer smaller than minimum size\n"); |
0ecca7a4 |
return -1;
} |
6f824977 |
if((avctx->codec->capabilities & CODEC_CAP_DELAY) || samples){ |
8eb027c8 |
int ret = avctx->codec->encode(avctx, buf, buf_size, samples); |
6f824977 |
avctx->frame_number++;
return ret;
}else
return 0; |
de6d9b64 |
}
|
5e4c7ca2 |
int attribute_align_arg avcodec_encode_video(AVCodecContext *avctx, uint8_t *buf, int buf_size, |
492cd3a9 |
const AVFrame *pict) |
de6d9b64 |
{ |
0ecca7a4 |
if(buf_size < FF_MIN_BUFFER_SIZE){ |
5286d11f |
av_log(avctx, AV_LOG_ERROR, "buffer smaller than minimum size\n"); |
0ecca7a4 |
return -1;
} |
e16f217c |
if(av_image_check_size(avctx->width, avctx->height, 0, avctx)) |
0ecca7a4 |
return -1; |
6f824977 |
if((avctx->codec->capabilities & CODEC_CAP_DELAY) || pict){ |
8eb027c8 |
int ret = avctx->codec->encode(avctx, buf, buf_size, pict); |
6f824977 |
avctx->frame_number++; |
bb628dae |
emms_c(); //needed to avoid an emms_c() call before every return; |
115329f1 |
|
6f824977 |
return ret;
}else
return 0; |
de6d9b64 |
}
|
115329f1 |
int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size, |
240c1657 |
const AVSubtitle *sub)
{
int ret; |
9413db9e |
if(sub->start_display_time) {
av_log(avctx, AV_LOG_ERROR, "start_display_time must be 0.\n");
return -1;
} |
423986fc |
|
8eb027c8 |
ret = avctx->codec->encode(avctx, buf, buf_size, sub); |
240c1657 |
avctx->frame_number++;
return ret;
}
|
76ad67ca |
/**
* Attempt to guess proper monotonic timestamps for decoded video frames
* which might have incorrect times. Input timestamps may wrap around, in
* which case the output will as well.
*
* @param pts the pts field of the decoded AVPacket, as passed through
* AVFrame.pkt_pts
* @param dts the dts field of the decoded AVPacket
* @return one of the input values, may be AV_NOPTS_VALUE
*/
static int64_t guess_correct_pts(AVCodecContext *ctx,
int64_t reordered_pts, int64_t dts)
{
int64_t pts = AV_NOPTS_VALUE;
if (dts != AV_NOPTS_VALUE) {
ctx->pts_correction_num_faulty_dts += dts <= ctx->pts_correction_last_dts;
ctx->pts_correction_last_dts = dts;
}
if (reordered_pts != AV_NOPTS_VALUE) {
ctx->pts_correction_num_faulty_pts += reordered_pts <= ctx->pts_correction_last_pts;
ctx->pts_correction_last_pts = reordered_pts;
}
if ((ctx->pts_correction_num_faulty_pts<=ctx->pts_correction_num_faulty_dts || dts == AV_NOPTS_VALUE)
&& reordered_pts != AV_NOPTS_VALUE)
pts = reordered_pts;
else
pts = dts;
return pts;
}
|
33651e3e |
#if FF_API_VIDEO_OLD
int attribute_align_arg avcodec_decode_video(AVCodecContext *avctx, AVFrame *picture,
int *got_picture_ptr,
const uint8_t *buf, int buf_size)
{
AVPacket avpkt;
av_init_packet(&avpkt);
avpkt.data = buf;
avpkt.size = buf_size;
// HACK for CorePNG to decode as normal PNG by default
avpkt.flags = AV_PKT_FLAG_KEY;
return avcodec_decode_video2(avctx, picture, got_picture_ptr, &avpkt);
}
#endif
|
7a00bbad |
int attribute_align_arg avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
int *got_picture_ptr,
AVPacket *avpkt)
{ |
de6d9b64 |
int ret; |
115329f1 |
|
53db1cae |
*got_picture_ptr= 0; |
e16f217c |
if((avctx->coded_width||avctx->coded_height) && av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx)) |
0ecca7a4 |
return -1; |
393cbb96 |
|
b38f008e |
if((avctx->codec->capabilities & CODEC_CAP_DELAY) || avpkt->size || (avctx->active_thread_type&FF_THREAD_FRAME)){ |
94eadee7 |
avctx->pkt = avpkt; |
b38f008e |
if (HAVE_PTHREADS && avctx->active_thread_type&FF_THREAD_FRAME)
ret = ff_thread_decode_frame(avctx, picture, got_picture_ptr,
avpkt);
else {
ret = avctx->codec->decode(avctx, picture, got_picture_ptr,
avpkt);
picture->pkt_dts= avpkt->dts; |
01d3ebaf |
if(!avctx->has_b_frames){ |
1ba57272 |
picture->pkt_pos= avpkt->pos; |
af2f7970 |
}
//FIXME these should be under if(!avctx->has_b_frames) |
77e9dee8 |
if (!picture->sample_aspect_ratio.num)
picture->sample_aspect_ratio = avctx->sample_aspect_ratio; |
22333a6b |
if (!picture->width)
picture->width = avctx->width;
if (!picture->height)
picture->height = avctx->height; |
18ded93a |
if (picture->format == PIX_FMT_NONE)
picture->format = avctx->pix_fmt; |
b38f008e |
} |
6bb925f4 |
|
bb628dae |
emms_c(); //needed to avoid an emms_c() call before every return; |
115329f1 |
|
1919feaf |
|
ad82bf9c |
if (*got_picture_ptr){ |
934982c4 |
avctx->frame_number++; |
ad82bf9c |
picture->best_effort_timestamp = guess_correct_pts(avctx,
picture->pkt_pts,
picture->pkt_dts);
} |
934982c4 |
}else
ret= 0;
|
de6d9b64 |
return ret;
}
|
a377cfa6 |
#if FF_API_AUDIO_OLD |
5e4c7ca2 |
int attribute_align_arg avcodec_decode_audio2(AVCodecContext *avctx, int16_t *samples, |
de6d9b64 |
int *frame_size_ptr, |
2efa7fd1 |
const uint8_t *buf, int buf_size) |
de6d9b64 |
{ |
7a00bbad |
AVPacket avpkt;
av_init_packet(&avpkt);
avpkt.data = buf;
avpkt.size = buf_size;
return avcodec_decode_audio3(avctx, samples, frame_size_ptr, &avpkt);
}
#endif
int attribute_align_arg avcodec_decode_audio3(AVCodecContext *avctx, int16_t *samples,
int *frame_size_ptr,
AVPacket *avpkt)
{ |
de6d9b64 |
int ret;
|
393cbb96 |
avctx->pkt = avpkt;
|
b8ab1adf |
if (!avpkt->data && avpkt->size) {
av_log(avctx, AV_LOG_ERROR, "invalid packet: NULL data, size != 0\n");
return AVERROR(EINVAL);
}
|
7a00bbad |
if((avctx->codec->capabilities & CODEC_CAP_DELAY) || avpkt->size){ |
9c856d62 |
//FIXME remove the check below _after_ ensuring that all audio check that the available space is enough
if(*frame_size_ptr < AVCODEC_MAX_AUDIO_FRAME_SIZE){
av_log(avctx, AV_LOG_ERROR, "buffer smaller than AVCODEC_MAX_AUDIO_FRAME_SIZE\n");
return -1;
}
if(*frame_size_ptr < FF_MIN_BUFFER_SIZE || |
81fc2f37 |
*frame_size_ptr < avctx->channels * avctx->frame_size * sizeof(int16_t)){ |
9c856d62 |
av_log(avctx, AV_LOG_ERROR, "buffer %d too small\n", *frame_size_ptr);
return -1;
}
|
7a00bbad |
ret = avctx->codec->decode(avctx, samples, frame_size_ptr, avpkt); |
fec9ccb7 |
avctx->frame_number++; |
ac66834c |
}else{ |
fec9ccb7 |
ret= 0; |
ac66834c |
*frame_size_ptr=0;
} |
de6d9b64 |
return ret;
}
|
448ce925 |
#if FF_API_SUBTITLE_OLD |
240c1657 |
int avcodec_decode_subtitle(AVCodecContext *avctx, AVSubtitle *sub,
int *got_sub_ptr,
const uint8_t *buf, int buf_size)
{ |
7a00bbad |
AVPacket avpkt;
av_init_packet(&avpkt);
avpkt.data = buf;
avpkt.size = buf_size;
return avcodec_decode_subtitle2(avctx, sub, got_sub_ptr, &avpkt);
}
#endif
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub,
int *got_sub_ptr,
AVPacket *avpkt)
{ |
240c1657 |
int ret;
|
393cbb96 |
avctx->pkt = avpkt; |
240c1657 |
*got_sub_ptr = 0; |
3ee8ca9b |
avcodec_get_subtitle_defaults(sub); |
7a00bbad |
ret = avctx->codec->decode(avctx, sub, got_sub_ptr, avpkt); |
240c1657 |
if (*got_sub_ptr)
avctx->frame_number++;
return ret;
}
|
e1d7c883 |
void avsubtitle_free(AVSubtitle *sub)
{
int i;
for (i = 0; i < sub->num_rects; i++)
{ |
8b834ac5 |
av_freep(&sub->rects[i]->pict.data[0]);
av_freep(&sub->rects[i]->pict.data[1]);
av_freep(&sub->rects[i]->pict.data[2]);
av_freep(&sub->rects[i]->pict.data[3]);
av_freep(&sub->rects[i]->text);
av_freep(&sub->rects[i]->ass);
av_freep(&sub->rects[i]); |
e1d7c883 |
}
|
8b834ac5 |
av_freep(&sub->rects); |
e1d7c883 |
memset(sub, 0, sizeof(AVSubtitle));
}
|
0752cd39 |
av_cold int avcodec_close(AVCodecContext *avctx) |
de6d9b64 |
{ |
f988ce6c |
/* If there is a user-supplied mutex locking routine, call it. */
if (ff_lockmgr_cb) {
if ((*ff_lockmgr_cb)(&codec_mutex, AV_LOCK_OBTAIN))
return -1;
}
|
ddebfb15 |
entangled_thread_counter++;
if(entangled_thread_counter != 1){
av_log(avctx, AV_LOG_ERROR, "insufficient thread locking around avcodec_open/close()\n");
entangled_thread_counter--;
return -1;
}
|
49fb20cb |
if (HAVE_THREADS && avctx->thread_opaque) |
043d2ff2 |
ff_thread_free(avctx); |
dccda293 |
if (avctx->codec && avctx->codec->close) |
de6d9b64 |
avctx->codec->close(avctx); |
eea8c08f |
avcodec_default_free_buffers(avctx); |
b3ab3199 |
avctx->coded_frame = NULL; |
f9569249 |
if (avctx->codec && avctx->codec->priv_class) |
36773283 |
av_opt_free(avctx->priv_data);
av_opt_free(avctx); |
3123dd79 |
av_freep(&avctx->priv_data); |
77a670e7 |
if(avctx->codec && avctx->codec->encode) |
c4f267ab |
av_freep(&avctx->extradata); |
de6d9b64 |
avctx->codec = NULL; |
b38f008e |
avctx->active_thread_type = 0; |
ddebfb15 |
entangled_thread_counter--; |
f988ce6c |
/* Release any user-supplied mutex. */
if (ff_lockmgr_cb) {
(*ff_lockmgr_cb)(&codec_mutex, AV_LOCK_RELEASE);
} |
de6d9b64 |
return 0;
}
AVCodec *avcodec_find_encoder(enum CodecID id)
{ |
93ebfeea |
AVCodec *p, *experimental=NULL; |
de6d9b64 |
p = first_avcodec;
while (p) { |
93ebfeea |
if (p->encode != NULL && p->id == id) {
if (p->capabilities & CODEC_CAP_EXPERIMENTAL && !experimental) {
experimental = p;
} else
return p;
} |
de6d9b64 |
p = p->next;
} |
93ebfeea |
return experimental; |
de6d9b64 |
}
|
98f3b098 |
AVCodec *avcodec_find_encoder_by_name(const char *name)
{
AVCodec *p; |
fc228c90 |
if (!name)
return NULL; |
98f3b098 |
p = first_avcodec;
while (p) {
if (p->encode != NULL && strcmp(name,p->name) == 0)
return p;
p = p->next;
}
return NULL;
}
|
de6d9b64 |
AVCodec *avcodec_find_decoder(enum CodecID id)
{ |
1bc81bf9 |
AVCodec *p, *experimental=NULL; |
de6d9b64 |
p = first_avcodec;
while (p) { |
1bc81bf9 |
if (p->decode != NULL && p->id == id) {
if (p->capabilities & CODEC_CAP_EXPERIMENTAL && !experimental) {
experimental = p;
} else
return p;
} |
de6d9b64 |
p = p->next;
} |
1bc81bf9 |
return experimental; |
de6d9b64 |
}
AVCodec *avcodec_find_decoder_by_name(const char *name)
{
AVCodec *p; |
fc228c90 |
if (!name)
return NULL; |
de6d9b64 |
p = first_avcodec;
while (p) {
if (p->decode != NULL && strcmp(name,p->name) == 0)
return p;
p = p->next;
}
return NULL;
}
|
406aa93f |
static int get_bit_rate(AVCodecContext *ctx) |
ce34ff6b |
{
int bit_rate;
int bits_per_sample;
switch(ctx->codec_type) { |
72415b2a |
case AVMEDIA_TYPE_VIDEO: |
4563cf24 |
case AVMEDIA_TYPE_DATA:
case AVMEDIA_TYPE_SUBTITLE:
case AVMEDIA_TYPE_ATTACHMENT: |
ce34ff6b |
bit_rate = ctx->bit_rate;
break; |
72415b2a |
case AVMEDIA_TYPE_AUDIO: |
ce34ff6b |
bits_per_sample = av_get_bits_per_sample(ctx->codec_id);
bit_rate = bits_per_sample ? ctx->sample_rate * ctx->channels * bits_per_sample : ctx->bit_rate;
break;
default:
bit_rate = 0;
break;
}
return bit_rate;
}
|
7e566bbe |
size_t av_get_codec_tag_string(char *buf, size_t buf_size, unsigned int codec_tag)
{
int i, len, ret = 0;
for (i = 0; i < 4; i++) {
len = snprintf(buf, buf_size,
isprint(codec_tag&0xFF) ? "%c" : "[%d]", codec_tag&0xFF);
buf += len;
buf_size = buf_size > len ? buf_size - len : 0;
ret += len;
codec_tag>>=8;
}
return ret;
}
|
de6d9b64 |
void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
{
const char *codec_name; |
2a81f4bd |
const char *profile = NULL; |
de6d9b64 |
AVCodec *p;
char buf1[32]; |
a96b68b7 |
int bitrate; |
59771f71 |
AVRational display_aspect_ratio; |
de6d9b64 |
if (encode)
p = avcodec_find_encoder(enc->codec_id);
else
p = avcodec_find_decoder(enc->codec_id);
if (p) {
codec_name = p->name; |
2a81f4bd |
profile = av_get_profile_name(p, enc->profile); |
985180a1 |
} else if (enc->codec_id == CODEC_ID_MPEG2TS) {
/* fake mpeg2 transport stream codec (currently not
registered) */
codec_name = "mpeg2ts"; |
de6d9b64 |
} else if (enc->codec_name[0] != '\0') {
codec_name = enc->codec_name;
} else {
/* output avi tags */ |
ab0b5378 |
char tag_buf[32];
av_get_codec_tag_string(tag_buf, sizeof(tag_buf), enc->codec_tag);
snprintf(buf1, sizeof(buf1), "%s / 0x%04X", tag_buf, enc->codec_tag); |
de6d9b64 |
codec_name = buf1;
}
switch(enc->codec_type) { |
72415b2a |
case AVMEDIA_TYPE_VIDEO: |
de6d9b64 |
snprintf(buf, buf_size,
"Video: %s%s", |
7d1c3fc1 |
codec_name, enc->mb_decision ? " (hq)" : ""); |
2a81f4bd |
if (profile)
snprintf(buf + strlen(buf), buf_size - strlen(buf),
" (%s)", profile); |
82c0c4ba |
if (enc->pix_fmt != PIX_FMT_NONE) { |
cf087595 |
snprintf(buf + strlen(buf), buf_size - strlen(buf),
", %s", |
94bed8e5 |
av_get_pix_fmt_name(enc->pix_fmt)); |
cf087595 |
} |
de6d9b64 |
if (enc->width) {
snprintf(buf + strlen(buf), buf_size - strlen(buf), |
21189011 |
", %dx%d",
enc->width, enc->height); |
7ee4dd02 |
if (enc->sample_aspect_ratio.num) { |
cbaf50f8 |
av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
enc->width*enc->sample_aspect_ratio.num,
enc->height*enc->sample_aspect_ratio.den,
1024*1024);
snprintf(buf + strlen(buf), buf_size - strlen(buf),
" [PAR %d:%d DAR %d:%d]",
enc->sample_aspect_ratio.num, enc->sample_aspect_ratio.den,
display_aspect_ratio.num, display_aspect_ratio.den); |
7ee4dd02 |
} |
a309073b |
if(av_log_get_level() >= AV_LOG_DEBUG){ |
9ce6c138 |
int g= av_gcd(enc->time_base.num, enc->time_base.den); |
21189011 |
snprintf(buf + strlen(buf), buf_size - strlen(buf),
", %d/%d",
enc->time_base.num/g, enc->time_base.den/g);
} |
de6d9b64 |
} |
4bfad535 |
if (encode) {
snprintf(buf + strlen(buf), buf_size - strlen(buf),
", q=%d-%d", enc->qmin, enc->qmax);
} |
de6d9b64 |
break; |
72415b2a |
case AVMEDIA_TYPE_AUDIO: |
de6d9b64 |
snprintf(buf, buf_size,
"Audio: %s",
codec_name); |
2a81f4bd |
if (profile)
snprintf(buf + strlen(buf), buf_size - strlen(buf),
" (%s)", profile); |
de6d9b64 |
if (enc->sample_rate) {
snprintf(buf + strlen(buf), buf_size - strlen(buf), |
0d72e7d0 |
", %d Hz", enc->sample_rate); |
de6d9b64 |
} |
0d72e7d0 |
av_strlcat(buf, ", ", buf_size); |
63e8d976 |
av_get_channel_layout_string(buf + strlen(buf), buf_size - strlen(buf), enc->channels, enc->channel_layout); |
5d6e4c16 |
if (enc->sample_fmt != AV_SAMPLE_FMT_NONE) { |
9e82a113 |
snprintf(buf + strlen(buf), buf_size - strlen(buf), |
ba7d6e79 |
", %s", av_get_sample_fmt_name(enc->sample_fmt)); |
9e82a113 |
} |
de6d9b64 |
break; |
72415b2a |
case AVMEDIA_TYPE_DATA: |
985180a1 |
snprintf(buf, buf_size, "Data: %s", codec_name); |
240c1657 |
break; |
72415b2a |
case AVMEDIA_TYPE_SUBTITLE: |
240c1657 |
snprintf(buf, buf_size, "Subtitle: %s", codec_name); |
985180a1 |
break; |
72415b2a |
case AVMEDIA_TYPE_ATTACHMENT: |
f8d7c9d3 |
snprintf(buf, buf_size, "Attachment: %s", codec_name);
break; |
de6d9b64 |
default: |
9fe5a7b8 |
snprintf(buf, buf_size, "Invalid Codec type %d", enc->codec_type);
return; |
de6d9b64 |
} |
4bfad535 |
if (encode) {
if (enc->flags & CODEC_FLAG_PASS1)
snprintf(buf + strlen(buf), buf_size - strlen(buf),
", pass 1");
if (enc->flags & CODEC_FLAG_PASS2)
snprintf(buf + strlen(buf), buf_size - strlen(buf),
", pass 2");
} |
406aa93f |
bitrate = get_bit_rate(enc); |
a96b68b7 |
if (bitrate != 0) { |
115329f1 |
snprintf(buf + strlen(buf), buf_size - strlen(buf), |
a96b68b7 |
", %d kb/s", bitrate / 1000); |
de6d9b64 |
}
}
|
060ec0a8 |
const char *av_get_profile_name(const AVCodec *codec, int profile)
{
const AVProfile *p;
if (profile == FF_PROFILE_UNKNOWN || !codec->profiles)
return NULL;
for (p = codec->profiles; p->profile != FF_PROFILE_UNKNOWN; p++)
if (p->profile == profile)
return p->name;
return NULL;
}
|
156e5023 |
unsigned avcodec_version( void )
{
return LIBAVCODEC_VERSION_INT;
} |
cf087595 |
|
41600690 |
const char *avcodec_configuration(void) |
c1736936 |
{ |
e528cdac |
return FFMPEG_CONFIGURATION; |
c1736936 |
}
|
41600690 |
const char *avcodec_license(void) |
c1736936 |
{
#define LICENSE_PREFIX "libavcodec license: " |
0cb88628 |
return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1; |
c1736936 |
}
|
de6d9b64 |
void avcodec_init(void)
{ |
5e534865 |
static int initialized = 0; |
0344cd0a |
|
5e534865 |
if (initialized != 0) |
bb270c08 |
return; |
5e534865 |
initialized = 1; |
0344cd0a |
|
486497e0 |
dsputil_static_init(); |
de6d9b64 |
}
|
1c2a8c7f |
void avcodec_flush_buffers(AVCodecContext *avctx)
{ |
b38f008e |
if(HAVE_PTHREADS && avctx->active_thread_type&FF_THREAD_FRAME)
ff_thread_flush(avctx); |
dc1b670a |
else if(avctx->codec->flush) |
7a06ff14 |
avctx->codec->flush(avctx); |
1c2a8c7f |
}
|
b100eab8 |
void avcodec_default_free_buffers(AVCodecContext *s){ |
d90cf87b |
int i, j;
if(s->internal_buffer==NULL) return; |
115329f1 |
|
ea09f691 |
if (s->internal_buffer_count)
av_log(s, AV_LOG_WARNING, "Found %i unreleased buffers!\n", s->internal_buffer_count); |
d90cf87b |
for(i=0; i<INTERNAL_BUFFER_SIZE; i++){
InternalBuffer *buf= &((InternalBuffer*)s->internal_buffer)[i];
for(j=0; j<4; j++){
av_freep(&buf->base[j]);
buf->data[j]= NULL;
}
}
av_freep(&s->internal_buffer); |
115329f1 |
|
d90cf87b |
s->internal_buffer_count=0;
}
|
bebe72f4 |
#if FF_API_OLD_FF_PICT_TYPES |
d8085ea7 |
char av_get_pict_type_char(int pict_type){ |
bebe72f4 |
return av_get_picture_type_char(pict_type); |
d8085ea7 |
} |
bebe72f4 |
#endif |
d8085ea7 |
|
ac3e1834 |
int av_get_bits_per_sample(enum CodecID codec_id){
switch(codec_id){ |
5da71469 |
case CODEC_ID_ADPCM_SBPRO_2: |
f1b163e0 |
return 2; |
5da71469 |
case CODEC_ID_ADPCM_SBPRO_3: |
f1b163e0 |
return 3; |
5da71469 |
case CODEC_ID_ADPCM_SBPRO_4: |
f1b163e0 |
case CODEC_ID_ADPCM_CT: |
07f2a575 |
case CODEC_ID_ADPCM_IMA_WAV: |
9df9b810 |
case CODEC_ID_ADPCM_MS:
case CODEC_ID_ADPCM_YAMAHA: |
f1b163e0 |
return 4; |
029f966c |
case CODEC_ID_ADPCM_G722: |
ac3e1834 |
case CODEC_ID_PCM_ALAW:
case CODEC_ID_PCM_MULAW:
case CODEC_ID_PCM_S8:
case CODEC_ID_PCM_U8: |
9d49b8ff |
case CODEC_ID_PCM_ZORK: |
ac3e1834 |
return 8;
case CODEC_ID_PCM_S16BE:
case CODEC_ID_PCM_S16LE: |
725d86bf |
case CODEC_ID_PCM_S16LE_PLANAR: |
ac3e1834 |
case CODEC_ID_PCM_U16BE:
case CODEC_ID_PCM_U16LE:
return 16;
case CODEC_ID_PCM_S24DAUD:
case CODEC_ID_PCM_S24BE:
case CODEC_ID_PCM_S24LE:
case CODEC_ID_PCM_U24BE:
case CODEC_ID_PCM_U24LE:
return 24;
case CODEC_ID_PCM_S32BE:
case CODEC_ID_PCM_S32LE:
case CODEC_ID_PCM_U32BE:
case CODEC_ID_PCM_U32LE: |
aa29709e |
case CODEC_ID_PCM_F32BE: |
143a5d6f |
case CODEC_ID_PCM_F32LE: |
ac3e1834 |
return 32; |
143a5d6f |
case CODEC_ID_PCM_F64BE:
case CODEC_ID_PCM_F64LE:
return 64; |
ac3e1834 |
default:
return 0;
}
}
|
6f84cd12 |
#if FF_API_OLD_SAMPLE_FMT |
5d6e4c16 |
int av_get_bits_per_sample_format(enum AVSampleFormat sample_fmt) { |
e6c52cee |
return av_get_bytes_per_sample(sample_fmt) << 3; |
42c71907 |
} |
6f84cd12 |
#endif |
42c71907 |
|
b250f9c6 |
#if !HAVE_THREADS |
46027c72 |
int ff_thread_init(AVCodecContext *s){ |
ca8ad847 |
return -1;
}
#endif |
ad2b531d |
unsigned int av_xiphlacing(unsigned char *s, unsigned int v)
{
unsigned int n = 0;
while(v >= 0xff) {
*s++ = 0xff;
v -= 0xff;
n++;
}
*s = v;
n++;
return n;
} |
1005f542 |
|
126b638e |
#if LIBAVCODEC_VERSION_MAJOR < 53 |
7ffe76e5 |
#include "libavutil/parseutils.h" |
26ef3220 |
int av_parse_video_frame_size(int *width_ptr, int *height_ptr, const char *str)
{ |
126b638e |
return av_parse_video_size(width_ptr, height_ptr, str); |
26ef3220 |
}
int av_parse_video_frame_rate(AVRational *frame_rate, const char *arg)
{ |
126b638e |
return av_parse_video_rate(frame_rate, arg); |
26ef3220 |
} |
126b638e |
#endif |
ea779d91 |
|
c46eeae2 |
int ff_match_2uint16(const uint16_t (*tab)[2], int size, int a, int b){
int i;
for(i=0; i<size && !(tab[i][0]==a && tab[i][1]==b); i++);
return i;
}
|
ce863d7f |
void av_log_missing_feature(void *avc, const char *feature, int want_sample) |
ea779d91 |
{
av_log(avc, AV_LOG_WARNING, "%s not implemented. Update your FFmpeg " |
db323491 |
"version to the newest one from Git. If the problem still " |
ea779d91 |
"occurs, it means that your file has a feature which has not " |
3fd3632f |
"been implemented.\n", feature); |
ea779d91 |
if(want_sample) |
ce863d7f |
av_log_ask_for_sample(avc, NULL); |
0ba39dd1 |
}
|
44f566b7 |
void av_log_ask_for_sample(void *avc, const char *msg, ...) |
0ba39dd1 |
{ |
44f566b7 |
va_list argument_list;
va_start(argument_list, msg);
|
0ba39dd1 |
if (msg) |
44f566b7 |
av_vlog(avc, AV_LOG_WARNING, msg, argument_list); |
0ba39dd1 |
av_log(avc, AV_LOG_WARNING, "If you want to help, upload a sample "
"of this file to ftp://upload.ffmpeg.org/MPlayer/incoming/ "
"and contact the ffmpeg-devel mailing list.\n"); |
44f566b7 |
va_end(argument_list); |
ea779d91 |
} |
c895618b |
static AVHWAccel *first_hwaccel = NULL;
void av_register_hwaccel(AVHWAccel *hwaccel)
{
AVHWAccel **p = &first_hwaccel;
while (*p)
p = &(*p)->next;
*p = hwaccel;
hwaccel->next = NULL;
} |
414d9d7f |
AVHWAccel *av_hwaccel_next(AVHWAccel *hwaccel)
{
return hwaccel ? hwaccel->next : first_hwaccel;
} |
6059f13c |
AVHWAccel *ff_find_hwaccel(enum CodecID codec_id, enum PixelFormat pix_fmt)
{
AVHWAccel *hwaccel=NULL;
while((hwaccel= av_hwaccel_next(hwaccel))){
if ( hwaccel->id == codec_id
&& hwaccel->pix_fmt == pix_fmt)
return hwaccel;
}
return NULL;
} |
f988ce6c |
int av_lockmgr_register(int (*cb)(void **mutex, enum AVLockOp op))
{
if (ff_lockmgr_cb) {
if (ff_lockmgr_cb(&codec_mutex, AV_LOCK_DESTROY))
return -1;
}
ff_lockmgr_cb = cb;
if (ff_lockmgr_cb) {
if (ff_lockmgr_cb(&codec_mutex, AV_LOCK_CREATE))
return -1;
}
return 0;
} |
603a5f04 |
unsigned int ff_toupper4(unsigned int x)
{
return toupper( x &0xFF)
+ (toupper((x>>8 )&0xFF)<<8 )
+ (toupper((x>>16)&0xFF)<<16)
+ (toupper((x>>24)&0xFF)<<24);
} |
b38f008e |
#if !HAVE_PTHREADS
int ff_thread_get_buffer(AVCodecContext *avctx, AVFrame *f)
{
f->owner = avctx;
return avctx->get_buffer(avctx, f);
}
void ff_thread_release_buffer(AVCodecContext *avctx, AVFrame *f)
{
f->owner->release_buffer(f->owner, f);
}
void ff_thread_finish_setup(AVCodecContext *avctx)
{
}
void ff_thread_report_progress(AVFrame *f, int progress, int field)
{
}
void ff_thread_await_progress(AVFrame *f, int progress, int field)
{
}
#endif |
043d2ff2 |
|
65af48b5 |
#if FF_API_THREAD_INIT |
043d2ff2 |
int avcodec_thread_init(AVCodecContext *s, int thread_count)
{ |
46027c72 |
s->thread_count = thread_count;
return ff_thread_init(s); |
043d2ff2 |
}
void avcodec_thread_free(AVCodecContext *s)
{ |
ee5bb31f |
#if HAVE_THREADS |
952f2315 |
ff_thread_free(s); |
ee5bb31f |
#endif |
043d2ff2 |
}
#endif |