videolan
/
ffmpeg
mirror of https://git.videolan.org/git/ffmpeg.git
1
Fork 0
Code Releases Activity

Merge remote-tracking branch 'qatar/master' 

* qatar/master:
  ffmpeg: fix some indentation
  ffmpeg: fix operation with --disable-avfilter
  simple_idct: remove disabled code
  motion_est: remove disabled code
  vc1: remove disabled code
  fate: separate lavf-mxf_d10 test from lavf-mxf
  cabac: Move code only used in the cabac test program to cabac.c.
  ffplay: warn that -pix_fmt is no longer working, suggest alternative
  ffplay: warn that -s is no longer working, suggest alternative
  lavf: rename enc variable in utils.c:has_codec_parameters()
  lavf: use designated initialisers for all (de)muxers.
  wav: remove a use of deprecated AV_METADATA_ macro
  rmdec: remove useless ap parameter from rm_read_header_old()
  dct-test: remove write-only variable
  des: fix #if conditional around P_shuffle
  Use LOCAL_ALIGNED in ff_check_alignment()

Conflicts:
	ffmpeg.c
	libavformat/avidec.c
	libavformat/matroskaenc.c
	libavformat/mp3enc.c
	libavformat/oggenc.c
	libavformat/utils.c
	tests/ref/lavf/mxf

Merged-by: Michael Niedermayer <michaelni@gmx.at>
This commit is contained in:
Michael Niedermayer 2011-07-17 19:52:05 +02:00
parent fc096e2e86 08e09ed7db
commit 78accb876c
150 changed files with 1488 additions and 2033 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
configure vendored
View File

@ -1604,7 +1604,7 @@ test_deps _muxer _demuxer \
mmf \
mov \
pcm_mulaw=mulaw \
mxf \
mxf="mxf mxf_d10" \
nut \
ogg \
rawvideo=pixfmt \

7
doc/ffplay.texi
View File

@ -38,8 +38,8 @@ Force displayed width.
@item -y @var{height}
Force displayed height.
@item -s @var{size}
Set frame size (WxH or abbreviation), needed for videos which don't
contain a header with the frame size like raw YUV.
This option has been removed. Use private format options for specifying the
input video size.
@item -an
Disable audio.
@item -vn
@ -89,7 +89,8 @@ Read @var{input_file}.
@section Advanced options
@table @option
@item -pix_fmt @var{format}
Set pixel format.
This option has been removed. Use private options for specifying the
input pixel format.
@item -stats
Show the stream duration, the codec parameters, the current position in
the stream and the audio/video synchronisation drift.

11
ffmpeg.c
View File

@ -2323,16 +2323,19 @@ static int transcode(AVFormatContext **output_files,
fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
ffmpeg_exit(1);
}
if (!codec->width || !codec->height) {
codec->width = icodec->width;
codec->height = icodec->height;
}
ost->video_resample = codec->width != icodec->width ||
codec->height != icodec->height ||
codec->pix_fmt != icodec->pix_fmt;
if (ost->video_resample) {
codec->bits_per_raw_sample= frame_bits_per_raw_sample;
}
if (!codec->width || !codec->height) {
codec->width = icodec->width;
codec->height = icodec->height;
}
ost->resample_height = icodec->height;
ost->resample_width = icodec->width;
ost->resample_pix_fmt= icodec->pix_fmt;

20
ffplay.c
View File

@ -223,9 +223,6 @@ static int fs_screen_width;
static int fs_screen_height;
static int screen_width = 0;
static int screen_height = 0;
static int frame_width = 0;
static int frame_height = 0;
static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
static int audio_disable;
static int video_disable;
static int wanted_stream[AVMEDIA_TYPE_NB]={
@ -2813,15 +2810,9 @@ static void event_loop(void)
static int opt_frame_size(const char *opt, const char *arg)
{
if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
fprintf(stderr, "Incorrect frame size\n");
return AVERROR(EINVAL);
}
if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
fprintf(stderr, "Frame size must be a multiple of 2\n");
return AVERROR(EINVAL);
}
return 0;
av_log(NULL, AV_LOG_ERROR,
"Option '%s' has been removed, use private format options instead\n", opt);
return AVERROR(EINVAL);
}
static int opt_width(const char *opt, const char *arg)
@ -2848,8 +2839,9 @@ static int opt_format(const char *opt, const char *arg)
static int opt_frame_pix_fmt(const char *opt, const char *arg)
{
frame_pix_fmt = av_get_pix_fmt(arg);
return 0;
av_log(NULL, AV_LOG_ERROR,
"Option '%s' has been removed, use private format options instead\n", opt);
return AVERROR(EINVAL);
}
static int opt_sync(const char *opt, const char *arg)

134
libavcodec/cabac.c
View File

@ -166,6 +166,140 @@ void ff_init_cabac_states(CABACContext *c){
#include "avcodec.h"
#include "cabac.h"
static void put_cabac(CABACContext *c, uint8_t * const state, int bit){
int RangeLPS= ff_h264_lps_range[2*(c->range&0xC0) + *state];
if(bit == ((*state)&1)){
c->range -= RangeLPS;
*state= ff_h264_mps_state[*state];
}else{
c->low += c->range - RangeLPS;
c->range = RangeLPS;
*state= ff_h264_lps_state[*state];
}
renorm_cabac_encoder(c);
#ifdef STRICT_LIMITS
c->symCount++;
#endif
}
/**
* @param bit 0 -> write zero bit, !=0 write one bit
*/
static void put_cabac_bypass(CABACContext *c, int bit){
c->low += c->low;
if(bit){
c->low += c->range;
}
//FIXME optimize
if(c->low<0x200){
put_cabac_bit(c, 0);
}else if(c->low<0x400){
c->outstanding_count++;
c->low -= 0x200;
}else{
put_cabac_bit(c, 1);
c->low -= 0x400;
}
#ifdef STRICT_LIMITS
c->symCount++;
#endif
}
/**
*
* @return the number of bytes written
*/
static int put_cabac_terminate(CABACContext *c, int bit){
c->range -= 2;
if(!bit){
renorm_cabac_encoder(c);
}else{
c->low += c->range;
c->range= 2;
renorm_cabac_encoder(c);
assert(c->low <= 0x1FF);
put_cabac_bit(c, c->low>>9);
put_bits(&c->pb, 2, ((c->low>>7)&3)|1);
flush_put_bits(&c->pb); //FIXME FIXME FIXME XXX wrong
}
#ifdef STRICT_LIMITS
c->symCount++;
#endif
return (put_bits_count(&c->pb)+7)>>3;
}
/**
* put (truncated) unary binarization.
*/
static void put_cabac_u(CABACContext *c, uint8_t * state, int v, int max, int max_index, int truncated){
int i;
assert(v <= max);
for(i=0; i<v; i++){
put_cabac(c, state, 1);
if(i < max_index) state++;
}
if(truncated==0 || v<max)
put_cabac(c, state, 0);
}
/**
* put unary exp golomb k-th order binarization.
*/
static void put_cabac_ueg(CABACContext *c, uint8_t * state, int v, int max, int is_signed, int k, int max_index){
int i;
if(v==0)
put_cabac(c, state, 0);
else{
const int sign= v < 0;
if(is_signed) v= FFABS(v);
if(v<max){
for(i=0; i<v; i++){
put_cabac(c, state, 1);
if(i < max_index) state++;
}
put_cabac(c, state, 0);
}else{
int m= 1<<k;
for(i=0; i<max; i++){
put_cabac(c, state, 1);
if(i < max_index) state++;
}
v -= max;
while(v >= m){ //FIXME optimize
put_cabac_bypass(c, 1);
v-= m;
m+= m;
}
put_cabac_bypass(c, 0);
while(m>>=1){
put_cabac_bypass(c, v&m);
}
}
if(is_signed)
put_cabac_bypass(c, sign);
}
}
int main(void){
CABACContext c;
uint8_t b[9*SIZE];

172
libavcodec/cabac.h
View File

@ -90,178 +90,6 @@ static inline void renorm_cabac_encoder(CABACContext *c){
}
}
#ifdef TEST
static void put_cabac(CABACContext *c, uint8_t * const state, int bit){
int RangeLPS= ff_h264_lps_range[2*(c->range&0xC0) + *state];
if(bit == ((*state)&1)){
c->range -= RangeLPS;
*state= ff_h264_mps_state[*state];
}else{
c->low += c->range - RangeLPS;
c->range = RangeLPS;
*state= ff_h264_lps_state[*state];
}
renorm_cabac_encoder(c);
#ifdef STRICT_LIMITS
c->symCount++;
#endif
}
static void put_cabac_static(CABACContext *c, int RangeLPS, int bit){
assert(c->range > RangeLPS);
if(!bit){
c->range -= RangeLPS;
}else{
c->low += c->range - RangeLPS;
c->range = RangeLPS;
}
renorm_cabac_encoder(c);
#ifdef STRICT_LIMITS
c->symCount++;
#endif
}
/**
* @param bit 0 -> write zero bit, !=0 write one bit
*/
static void put_cabac_bypass(CABACContext *c, int bit){
c->low += c->low;
if(bit){
c->low += c->range;
}
//FIXME optimize
if(c->low<0x200){
put_cabac_bit(c, 0);
}else if(c->low<0x400){
c->outstanding_count++;
c->low -= 0x200;
}else{
put_cabac_bit(c, 1);
c->low -= 0x400;
}
#ifdef STRICT_LIMITS
c->symCount++;
#endif
}
/**
*
* @return the number of bytes written
*/
static int put_cabac_terminate(CABACContext *c, int bit){
c->range -= 2;
if(!bit){
renorm_cabac_encoder(c);
}else{
c->low += c->range;
c->range= 2;
renorm_cabac_encoder(c);
assert(c->low <= 0x1FF);
put_cabac_bit(c, c->low>>9);
put_bits(&c->pb, 2, ((c->low>>7)&3)|1);
flush_put_bits(&c->pb); //FIXME FIXME FIXME XXX wrong
}
#ifdef STRICT_LIMITS
c->symCount++;
#endif
return (put_bits_count(&c->pb)+7)>>3;
}
/**
* put (truncated) unary binarization.
*/
static void put_cabac_u(CABACContext *c, uint8_t * state, int v, int max, int max_index, int truncated){
int i;
assert(v <= max);
#if 1
for(i=0; i<v; i++){
put_cabac(c, state, 1);
if(i < max_index) state++;
}
if(truncated==0 || v<max)
put_cabac(c, state, 0);
#else
if(v <= max_index){
for(i=0; i<v; i++){
put_cabac(c, state+i, 1);
}
if(truncated==0 || v<max)
put_cabac(c, state+i, 0);
}else{
for(i=0; i<=max_index; i++){
put_cabac(c, state+i, 1);
}
for(; i<v; i++){
put_cabac(c, state+max_index, 1);
}
if(truncated==0 || v<max)
put_cabac(c, state+max_index, 0);
}
#endif
}
/**
* put unary exp golomb k-th order binarization.
*/
static void put_cabac_ueg(CABACContext *c, uint8_t * state, int v, int max, int is_signed, int k, int max_index){
int i;
if(v==0)
put_cabac(c, state, 0);
else{
const int sign= v < 0;
if(is_signed) v= FFABS(v);
if(v<max){
for(i=0; i<v; i++){
put_cabac(c, state, 1);
if(i < max_index) state++;
}
put_cabac(c, state, 0);
}else{
int m= 1<<k;
for(i=0; i<max; i++){
put_cabac(c, state, 1);
if(i < max_index) state++;
}
v -= max;
while(v >= m){ //FIXME optimize
put_cabac_bypass(c, 1);
v-= m;
m+= m;
}
put_cabac_bypass(c, 0);
while(m>>=1){
put_cabac_bypass(c, v&m);
}
}
if(is_signed)
put_cabac_bypass(c, sign);
}
}
#endif /* TEST */
static void refill(CABACContext *c){
#if CABAC_BITS == 16
c->low+= (c->bytestream[0]<<9) + (c->bytestream[1]<<1);

4
libavcodec/dct-test.c
View File

@ -190,7 +190,6 @@ static void idct_mmx_init(void)
DECLARE_ALIGNED(16, static DCTELEM, block)[64];
DECLARE_ALIGNED(8, static DCTELEM, block1)[64];
DECLARE_ALIGNED(8, static DCTELEM, block_org)[64];
static inline void mmx_emms(void)
{
@ -246,9 +245,6 @@ static int dct_error(const struct algo *dct, int test, int is_idct, int speed, c
break;
}
for (i = 0; i < 64; i++)
block_org[i] = block1[i];
if (dct->format == MMX_PERM) {
for (i = 0; i < 64; i++)
block[idct_mmx_perm[i]] = block1[i];

2
libavcodec/dsputil.c
View File

@ -2832,7 +2832,7 @@ av_cold void dsputil_static_init(void)
int ff_check_alignment(void){
static int did_fail=0;
DECLARE_ALIGNED(16, int, aligned);
LOCAL_ALIGNED_16(int, aligned);
if((intptr_t)&aligned & 15){
if(!did_fail){

52
libavcodec/motion_est.c
View File

@ -374,30 +374,6 @@ int ff_init_me(MpegEncContext *s){
return 0;
}
#if 0
static int pix_dev(uint8_t * pix, int line_size, int mean)
{
int s, i, j;
s = 0;
for (i = 0; i < 16; i++) {
for (j = 0; j < 16; j += 8) {
s += FFABS(pix[0]-mean);
s += FFABS(pix[1]-mean);
s += FFABS(pix[2]-mean);
s += FFABS(pix[3]-mean);
s += FFABS(pix[4]-mean);
s += FFABS(pix[5]-mean);
s += FFABS(pix[6]-mean);
s += FFABS(pix[7]-mean);
pix += 8;
}
pix += line_size - 16;
}
return s;
}
#endif
static inline void no_motion_search(MpegEncContext * s,
int *mx_ptr, int *my_ptr)
{
@ -1214,30 +1190,6 @@ void ff_estimate_p_frame_motion(MpegEncContext * s,
intra_score= s->dsp.mb_cmp[0](s, c->scratchpad, pix, s->linesize, 16);
}
#if 0 //FIXME
/* get chroma score */
if(c->avctx->mb_cmp&FF_CMP_CHROMA){
for(i=1; i<3; i++){
uint8_t *dest_c;
int mean;
if(s->out_format == FMT_H263){
mean= (s->dc_val[i][mb_x + mb_y*s->b8_stride] + 4)>>3; //FIXME not exact but simple ;)
}else{
mean= (s->last_dc[i] + 4)>>3;
}
dest_c = s->new_picture.f.data[i] + (mb_y * 8 * (s->uvlinesize)) + mb_x * 8;
mean*= 0x01010101;
for(i=0; i<8; i++){
*(uint32_t*)(&c->scratchpad[i*s->uvlinesize+ 0]) = mean;
*(uint32_t*)(&c->scratchpad[i*s->uvlinesize+ 4]) = mean;
}
intra_score+= s->dsp.mb_cmp[1](s, c->scratchpad, dest_c, s->uvlinesize);
}
}
#endif
intra_score += c->mb_penalty_factor*16;
if(intra_score < dmin){
@ -1850,10 +1802,6 @@ void ff_estimate_b_frame_motion(MpegEncContext * s,
if(dmin>256*256*16) type&= ~CANDIDATE_MB_TYPE_DIRECT; //do not try direct mode if it is invalid for this MB
if(s->codec_id == CODEC_ID_MPEG4 && type&CANDIDATE_MB_TYPE_DIRECT && s->flags&CODEC_FLAG_MV0 && *(uint32_t*)s->b_direct_mv_table[xy])
type |= CANDIDATE_MB_TYPE_DIRECT0;
#if 0
if(s->out_format == FMT_MPEG1)
type |= CANDIDATE_MB_TYPE_INTRA;
#endif
}
s->mb_type[mb_y*s->mb_stride + mb_x]= type;

141
libavcodec/motion_est_template.c
View File

@ -44,75 +44,6 @@
COPY3_IF_LT(dmin, d, bx, hx, by, hy)\
}
#if 0
static int hpel_motion_search)(MpegEncContext * s,
int *mx_ptr, int *my_ptr, int dmin,
uint8_t *ref_data[3],
int size)
{
const int xx = 16 * s->mb_x + 8*(n&1);
const int yy = 16 * s->mb_y + 8*(n>>1);
const int mx = *mx_ptr;
const int my = *my_ptr;
const int penalty_factor= c->sub_penalty_factor;
LOAD_COMMON
// INIT;
//FIXME factorize
me_cmp_func cmp, chroma_cmp, cmp_sub, chroma_cmp_sub;
if(s->no_rounding /*FIXME b_type*/){
hpel_put= &s->dsp.put_no_rnd_pixels_tab[size];
chroma_hpel_put= &s->dsp.put_no_rnd_pixels_tab[size+1];
}else{
hpel_put=& s->dsp.put_pixels_tab[size];
chroma_hpel_put= &s->dsp.put_pixels_tab[size+1];
}
cmpf= s->dsp.me_cmp[size];
chroma_cmpf= s->dsp.me_cmp[size+1];
cmp_sub= s->dsp.me_sub_cmp[size];
chroma_cmp_sub= s->dsp.me_sub_cmp[size+1];
if(c->skip){ //FIXME somehow move up (benchmark)
*mx_ptr = 0;
*my_ptr = 0;
return dmin;
}
if(c->avctx->me_cmp != c->avctx->me_sub_cmp){
CMP_HPEL(dmin, 0, 0, mx, my, size);
if(mx || my)
dmin += (mv_penalty[2*mx - pred_x] + mv_penalty[2*my - pred_y])*penalty_factor;
}
if (mx > xmin && mx < xmax &&
my > ymin && my < ymax) {
int bx=2*mx, by=2*my;
int d= dmin;
CHECK_HALF_MV(1, 1, mx-1, my-1)
CHECK_HALF_MV(0, 1, mx , my-1)
CHECK_HALF_MV(1, 1, mx , my-1)
CHECK_HALF_MV(1, 0, mx-1, my )
CHECK_HALF_MV(1, 0, mx , my )
CHECK_HALF_MV(1, 1, mx-1, my )
CHECK_HALF_MV(0, 1, mx , my )
CHECK_HALF_MV(1, 1, mx , my )
assert(bx >= xmin*2 || bx <= xmax*2 || by >= ymin*2 || by <= ymax*2);
*mx_ptr = bx;
*my_ptr = by;
}else{
*mx_ptr =2*mx;
*my_ptr =2*my;
}
return dmin;
}
#else
static int hpel_motion_search(MpegEncContext * s,
int *mx_ptr, int *my_ptr, int dmin,
int src_index, int ref_index,
@ -220,7 +151,6 @@ static int hpel_motion_search(MpegEncContext * s,
return dmin;
}
#endif
static int no_sub_motion_search(MpegEncContext * s,
int *mx_ptr, int *my_ptr, int dmin,
@ -323,7 +253,6 @@ static int qpel_motion_search(MpegEncContext * s,
int best_pos[8][2];
memset(best, 64, sizeof(int)*8);
#if 1
if(s->me.dia_size>=2){
const int tl= score_map[(index-(1<<ME_MAP_SHIFT)-1)&(ME_MAP_SIZE-1)];
const int bl= score_map[(index+(1<<ME_MAP_SHIFT)-1)&(ME_MAP_SIZE-1)];
@ -412,76 +341,6 @@ static int qpel_motion_search(MpegEncContext * s,
CHECK_QUARTER_MV(nx&3, ny&3, nx>>2, ny>>2)
}
#if 0
const int tl= score_map[(index-(1<<ME_MAP_SHIFT)-1)&(ME_MAP_SIZE-1)];
const int bl= score_map[(index+(1<<ME_MAP_SHIFT)-1)&(ME_MAP_SIZE-1)];
const int tr= score_map[(index-(1<<ME_MAP_SHIFT)+1)&(ME_MAP_SIZE-1)];
const int br= score_map[(index+(1<<ME_MAP_SHIFT)+1)&(ME_MAP_SIZE-1)];
// if(l < r && l < t && l < b && l < tl && l < bl && l < tr && l < br && bl < tl){
if(tl<br){
// nx= FFMAX(4*mx - bx, bx - 4*mx);
// ny= FFMAX(4*my - by, by - 4*my);
static int stats[7][7], count;
count++;
stats[4*mx - bx + 3][4*my - by + 3]++;
if(256*256*256*64 % count ==0){
for(i=0; i<49; i++){
if((i%7)==0) printf("\n");
printf("%6d ", stats[0][i]);
}
printf("\n");
}
}
#endif
#else
CHECK_QUARTER_MV(2, 2, mx-1, my-1)
CHECK_QUARTER_MV(0, 2, mx , my-1)
CHECK_QUARTER_MV(2, 2, mx , my-1)
CHECK_QUARTER_MV(2, 0, mx , my )
CHECK_QUARTER_MV(2, 2, mx , my )
CHECK_QUARTER_MV(0, 2, mx , my )
CHECK_QUARTER_MV(2, 2, mx-1, my )
CHECK_QUARTER_MV(2, 0, mx-1, my )
nx= bx;
ny= by;
for(i=0; i<8; i++){
int ox[8]= {0, 1, 1, 1, 0,-1,-1,-1};
int oy[8]= {1, 1, 0,-1,-1,-1, 0, 1};
CHECK_QUARTER_MV((nx + ox[i])&3, (ny + oy[i])&3, (nx + ox[i])>>2, (ny + oy[i])>>2)
}
#endif
#if 0
//outer ring
CHECK_QUARTER_MV(1, 3, mx-1, my-1)
CHECK_QUARTER_MV(1, 2, mx-1, my-1)
CHECK_QUARTER_MV(1, 1, mx-1, my-1)
CHECK_QUARTER_MV(2, 1, mx-1, my-1)
CHECK_QUARTER_MV(3, 1, mx-1, my-1)
CHECK_QUARTER_MV(0, 1, mx , my-1)
CHECK_QUARTER_MV(1, 1, mx , my-1)
CHECK_QUARTER_MV(2, 1, mx , my-1)
CHECK_QUARTER_MV(3, 1, mx , my-1)
CHECK_QUARTER_MV(3, 2, mx , my-1)
CHECK_QUARTER_MV(3, 3, mx , my-1)
CHECK_QUARTER_MV(3, 0, mx , my )
CHECK_QUARTER_MV(3, 1, mx , my )
CHECK_QUARTER_MV(3, 2, mx , my )
CHECK_QUARTER_MV(3, 3, mx , my )
CHECK_QUARTER_MV(2, 3, mx , my )
CHECK_QUARTER_MV(1, 3, mx , my )
CHECK_QUARTER_MV(0, 3, mx , my )
CHECK_QUARTER_MV(3, 3, mx-1, my )
CHECK_QUARTER_MV(2, 3, mx-1, my )
CHECK_QUARTER_MV(1, 3, mx-1, my )
CHECK_QUARTER_MV(1, 2, mx-1, my )
CHECK_QUARTER_MV(1, 1, mx-1, my )
CHECK_QUARTER_MV(1, 0, mx-1, my )
#endif
assert(bx >= xmin*4 && bx <= xmax*4 && by >= ymin*4 && by <= ymax*4);
*mx_ptr = bx;

12
libavcodec/simple_idct.c
View File

@ -34,17 +34,6 @@
#include "mathops.h"
#include "simple_idct.h"
#if 0
#define W1 2841 /* 2048*sqrt (2)*cos (1*pi/16) */
#define W2 2676 /* 2048*sqrt (2)*cos (2*pi/16) */
#define W3 2408 /* 2048*sqrt (2)*cos (3*pi/16) */
#define W4 2048 /* 2048*sqrt (2)*cos (4*pi/16) */
#define W5 1609 /* 2048*sqrt (2)*cos (5*pi/16) */
#define W6 1108 /* 2048*sqrt (2)*cos (6*pi/16) */
#define W7 565 /* 2048*sqrt (2)*cos (7*pi/16) */
#define ROW_SHIFT 8
#define COL_SHIFT 17
#else
#define W1 22725 //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
#define W2 21407 //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
#define W3 19266 //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
@ -54,7 +43,6 @@
#define W7 4520 //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
#define ROW_SHIFT 11
#define COL_SHIFT 20 // 6
#endif
static inline void idctRowCondDC (DCTELEM * row)
{

9
libavcodec/vc1data.h
View File

@ -74,20 +74,11 @@ extern VLC ff_vc1_ac_coeff_table[8];
//@}
#if 0 //original bfraction from vc9data.h, not conforming to standard
/* Denominator used for ff_vc1_bfraction_lut */
#define B_FRACTION_DEN 840
/* bfraction is fractional, we scale to the GCD 3*5*7*8 = 840 */
extern const int16_t ff_vc1_bfraction_lut[23];
#else
/* Denominator used for ff_vc1_bfraction_lut */
#define B_FRACTION_DEN 256
/* pre-computed scales for all bfractions and base=256 */
extern const int16_t ff_vc1_bfraction_lut[23];
#endif
extern const uint8_t ff_vc1_bfraction_bits[23];
extern const uint8_t ff_vc1_bfraction_codes[23];

133
libavcodec/x86/simple_idct_mmx.c
View File

@ -37,11 +37,7 @@
#define C1 22725 //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
#define C2 21407 //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
#define C3 19266 //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
#if 0
#define C4 16384 //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
#else
#define C4 16383 //cos(i*M_PI/16)*sqrt(2)*(1<<14) - 0.5
#endif
#define C5 12873 //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
#define C6 8867 //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
#define C7 4520 //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
@ -80,135 +76,6 @@ DECLARE_ALIGNED(8, static const int16_t, coeffs)[]= {
C3, -C1, C3, -C1
};
#if 0
static void unused_var_killer(void)
{
int a= wm1010 + d40000;
temp[0]=a;
}
static void inline idctCol (int16_t * col, int16_t *input)
{
#undef C0
#undef C1
#undef C2
#undef C3
#undef C4
#undef C5
#undef C6
#undef C7
int a0, a1, a2, a3, b0, b1, b2, b3;
const int C0 = 23170; //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
const int C1 = 22725; //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
const int C2 = 21407; //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
const int C3 = 19266; //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
const int C4 = 16383; //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
const int C5 = 12873; //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
const int C6 = 8867; //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
const int C7 = 4520; //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
/*
if( !(col[8*1] | col[8*2] |col[8*3] |col[8*4] |col[8*5] |col[8*6] | col[8*7])) {
col[8*0] = col[8*1] = col[8*2] = col[8*3] = col[8*4] =
col[8*5] = col[8*6] = col[8*7] = col[8*0]<<3;
return;
}*/
col[8*0] = input[8*0 + 0];
col[8*1] = input[8*2 + 0];
col[8*2] = input[8*0 + 1];
col[8*3] = input[8*2 + 1];
col[8*4] = input[8*4 + 0];
col[8*5] = input[8*6 + 0];
col[8*6] = input[8*4 + 1];
col[8*7] = input[8*6 + 1];
a0 = C4*col[8*0] + C2*col[8*2] + C4*col[8*4] + C6*col[8*6] + (1<<(COL_SHIFT-1));
a1 = C4*col[8*0] + C6*col[8*2] - C4*col[8*4] - C2*col[8*6] + (1<<(COL_SHIFT-1));
a2 = C4*col[8*0] - C6*col[8*2] - C4*col[8*4] + C2*col[8*6] + (1<<(COL_SHIFT-1));
a3 = C4*col[8*0] - C2*col[8*2] + C4*col[8*4] - C6*col[8*6] + (1<<(COL_SHIFT-1));
b0 = C1*col[8*1] + C3*col[8*3] + C5*col[8*5] + C7*col[8*7];
b1 = C3*col[8*1] - C7*col[8*3] - C1*col[8*5] - C5*col[8*7];
b2 = C5*col[8*1] - C1*col[8*3] + C7*col[8*5] + C3*col[8*7];
b3 = C7*col[8*1] - C5*col[8*3] + C3*col[8*5] - C1*col[8*7];
col[8*0] = (a0 + b0) >> COL_SHIFT;
col[8*1] = (a1 + b1) >> COL_SHIFT;
col[8*2] = (a2 + b2) >> COL_SHIFT;
col[8*3] = (a3 + b3) >> COL_SHIFT;
col[8*4] = (a3 - b3) >> COL_SHIFT;
col[8*5] = (a2 - b2) >> COL_SHIFT;
col[8*6] = (a1 - b1) >> COL_SHIFT;
col[8*7] = (a0 - b0) >> COL_SHIFT;
}
static void inline idctRow (int16_t * output, int16_t * input)
{
int16_t row[8];
int a0, a1, a2, a3, b0, b1, b2, b3;
const int C0 = 23170; //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
const int C1 = 22725; //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
const int C2 = 21407; //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
const int C3 = 19266; //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
const int C4 = 16383; //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
const int C5 = 12873; //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
const int C6 = 8867; //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
const int C7 = 4520; //cos(i*M_PI/16)*sqrt(2)*(1<<14) + 0.5
row[0] = input[0];
row[2] = input[1];
row[4] = input[4];
row[6] = input[5];
row[1] = input[8];
row[3] = input[9];
row[5] = input[12];
row[7] = input[13];
if( !(row[1] | row[2] |row[3] |row[4] |row[5] |row[6] | row[7]) ) {
row[0] = row[1] = row[2] = row[3] = row[4] =
row[5] = row[6] = row[7] = row[0]<<3;
output[0] = row[0];
output[2] = row[1];
output[4] = row[2];
output[6] = row[3];
output[8] = row[4];
output[10] = row[5];
output[12] = row[6];
output[14] = row[7];
return;
}
a0 = C4*row[0] + C2*row[2] + C4*row[4] + C6*row[6] + (1<<(ROW_SHIFT-1));
a1 = C4*row[0] + C6*row[2] - C4*row[4] - C2*row[6] + (1<<(ROW_SHIFT-1));
a2 = C4*row[0] - C6*row[2] - C4*row[4] + C2*row[6] + (1<<(ROW_SHIFT-1));
a3 = C4*row[0] - C2*row[2] + C4*row[4] - C6*row[6] + (1<<(ROW_SHIFT-1));
b0 = C1*row[1] + C3*row[3] + C5*row[5] + C7*row[7];
b1 = C3*row[1] - C7*row[3] - C1*row[5] - C5*row[7];
b2 = C5*row[1] - C1*row[3] + C7*row[5] + C3*row[7];
b3 = C7*row[1] - C5*row[3] + C3*row[5] - C1*row[7];
row[0] = (a0 + b0) >> ROW_SHIFT;
row[1] = (a1 + b1) >> ROW_SHIFT;
row[2] = (a2 + b2) >> ROW_SHIFT;
row[3] = (a3 + b3) >> ROW_SHIFT;
row[4] = (a3 - b3) >> ROW_SHIFT;
row[5] = (a2 - b2) >> ROW_SHIFT;
row[6] = (a1 - b1) >> ROW_SHIFT;
row[7] = (a0 - b0) >> ROW_SHIFT;
output[0] = row[0];
output[2] = row[1];
output[4] = row[2];
output[6] = row[3];
output[8] = row[4];
output[10] = row[5];
output[12] = row[6];
output[14] = row[7];
}
#endif
static inline void idct(int16_t *block)
{
DECLARE_ALIGNED(8, int64_t, align_tmp)[16];

14
libavformat/4xm.c
View File

@ -345,11 +345,11 @@ static int fourxm_read_close(AVFormatContext *s)
}
AVInputFormat ff_fourxm_demuxer = {
"4xm",
NULL_IF_CONFIG_SMALL("4X Technologies format"),
sizeof(FourxmDemuxContext),
fourxm_probe,
fourxm_read_header,
fourxm_read_packet,
fourxm_read_close,
.name = "4xm",
.long_name = NULL_IF_CONFIG_SMALL("4X Technologies format"),
.priv_data_size = sizeof(FourxmDemuxContext),
.read_probe = fourxm_probe,
.read_header = fourxm_read_header,
.read_packet = fourxm_read_packet,
.read_close = fourxm_read_close,
};

6
libavformat/a64.c
View File

@ -170,7 +170,7 @@ AVOutputFormat ff_a64_muxer = {
.extensions = "a64, A64",
.priv_data_size = sizeof (A64Context),
.video_codec = CODEC_ID_A64_MULTI,
a64_write_header,
a64_write_packet,
a64_write_trailer
.write_header = a64_write_header,
.write_packet = a64_write_packet,
.write_trailer = a64_write_trailer
};

11
libavformat/aacdec.c
View File

@ -82,12 +82,11 @@ static int adts_aac_read_header(AVFormatContext *s,
}
AVInputFormat ff_aac_demuxer = {
"aac",
NULL_IF_CONFIG_SMALL("raw ADTS AAC"),
0,
adts_aac_probe,
adts_aac_read_header,
ff_raw_read_partial_packet,
.name = "aac",
.long_name = NULL_IF_CONFIG_SMALL("raw ADTS AAC"),
.read_probe = adts_aac_probe,
.read_header = adts_aac_read_header,
.read_packet = ff_raw_read_partial_packet,
.flags= AVFMT_GENERIC_INDEX,
.extensions = "aac",
.value = CODEC_ID_AAC,

22
libavformat/ac3dec.c
View File

@ -71,12 +71,11 @@ static int ac3_probe(AVProbeData *p)
}
AVInputFormat ff_ac3_demuxer = {
"ac3",
NULL_IF_CONFIG_SMALL("raw AC-3"),
0,
ac3_probe,
ff_raw_audio_read_header,
ff_raw_read_partial_packet,
.name = "ac3",
.long_name = NULL_IF_CONFIG_SMALL("raw AC-3"),
.read_probe = ac3_probe,
.read_header = ff_raw_audio_read_header,
.read_packet = ff_raw_read_partial_packet,
.flags= AVFMT_GENERIC_INDEX,
.extensions = "ac3",
.value = CODEC_ID_AC3,
@ -90,12 +89,11 @@ static int eac3_probe(AVProbeData *p)
}
AVInputFormat ff_eac3_demuxer = {
"eac3",
NULL_IF_CONFIG_SMALL("raw E-AC-3"),
0,
eac3_probe,
ff_raw_audio_read_header,
ff_raw_read_partial_packet,
.name = "eac3",
.long_name = NULL_IF_CONFIG_SMALL("raw E-AC-3"),
.read_probe = eac3_probe,
.read_header = ff_raw_audio_read_header,
.read_packet = ff_raw_read_partial_packet,
.flags= AVFMT_GENERIC_INDEX,
.extensions = "eac3",
.value = CODEC_ID_EAC3,

18
libavformat/adtsenc.c
View File

@ -142,13 +142,13 @@ static int adts_write_packet(AVFormatContext *s, AVPacket *pkt)
}
AVOutputFormat ff_adts_muxer = {
"adts",
NULL_IF_CONFIG_SMALL("ADTS AAC"),
"audio/aac",
"aac,adts",
sizeof(ADTSContext),
CODEC_ID_AAC,
CODEC_ID_NONE,
adts_write_header,
adts_write_packet,
.name = "adts",
.long_name = NULL_IF_CONFIG_SMALL("ADTS AAC"),
.mime_type = "audio/aac",
.extensions = "aac,adts",
.priv_data_size = sizeof(ADTSContext),
.audio_codec = CODEC_ID_AAC,
.video_codec = CODEC_ID_NONE,
.write_header = adts_write_header,
.write_packet = adts_write_packet,
};

14
libavformat/aea.c
View File

@ -95,14 +95,12 @@ static int aea_read_packet(AVFormatContext *s, AVPacket *pkt)
}
AVInputFormat ff_aea_demuxer = {
"aea",
NULL_IF_CONFIG_SMALL("MD STUDIO audio"),
0,
aea_read_probe,
aea_read_header,
aea_read_packet,
0,
pcm_read_seek,
.name = "aea",
.long_name = NULL_IF_CONFIG_SMALL("MD STUDIO audio"),
.read_probe = aea_read_probe,
.read_header = aea_read_header,
.read_packet = aea_read_packet,
.read_seek = pcm_read_seek,
.flags= AVFMT_GENERIC_INDEX,
.extensions = "aea",
};

15
libavformat/aiffdec.c
View File

@ -320,13 +320,12 @@ static int aiff_read_packet(AVFormatContext *s,
}
AVInputFormat ff_aiff_demuxer = {
"aiff",
NULL_IF_CONFIG_SMALL("Audio IFF"),
sizeof(AIFFInputContext),
aiff_probe,
aiff_read_header,
aiff_read_packet,
NULL,
pcm_read_seek,
.name = "aiff",
.long_name = NULL_IF_CONFIG_SMALL("Audio IFF"),
.priv_data_size = sizeof(AIFFInputContext),
.read_probe = aiff_probe,
.read_header = aiff_read_header,
.read_packet = aiff_read_packet,
.read_seek = pcm_read_seek,
.codec_tag= (const AVCodecTag* const []){ff_codec_aiff_tags, 0},
};

20
libavformat/aiffenc.c
View File

@ -155,15 +155,15 @@ static int aiff_write_trailer(AVFormatContext *s)
}
AVOutputFormat ff_aiff_muxer = {
"aiff",
NULL_IF_CONFIG_SMALL("Audio IFF"),
"audio/aiff",
"aif,aiff,afc,aifc",
sizeof(AIFFOutputContext),
CODEC_ID_PCM_S16BE,
CODEC_ID_NONE,
aiff_write_header,
aiff_write_packet,
aiff_write_trailer,
.name = "aiff",
.long_name = NULL_IF_CONFIG_SMALL("Audio IFF"),
.mime_type = "audio/aiff",
.extensions = "aif,aiff,afc,aifc",
.priv_data_size = sizeof(AIFFOutputContext),
.audio_codec = CODEC_ID_PCM_S16BE,
.video_codec = CODEC_ID_NONE,
.write_header = aiff_write_header,
.write_packet = aiff_write_packet,
.write_trailer = aiff_write_trailer,
.codec_tag= (const AVCodecTag* const []){ff_codec_aiff_tags, 0},
};

30
libavformat/amr.c
View File

@ -174,27 +174,25 @@ static int amr_read_packet(AVFormatContext *s,
#if CONFIG_AMR_DEMUXER
AVInputFormat ff_amr_demuxer = {
"amr",
NULL_IF_CONFIG_SMALL("3GPP AMR file format"),
0, /*priv_data_size*/
amr_probe,
amr_read_header,
amr_read_packet,
NULL,
.name = "amr",
.long_name = NULL_IF_CONFIG_SMALL("3GPP AMR file format"),
.priv_data_size = 0, /*priv_data_size*/
.read_probe = amr_probe,
.read_header = amr_read_header,
.read_packet = amr_read_packet,
.flags = AVFMT_GENERIC_INDEX,
};
#endif
#if CONFIG_AMR_MUXER
AVOutputFormat ff_amr_muxer = {
"amr",
NULL_IF_CONFIG_SMALL("3GPP AMR file format"),
"audio/amr",
"amr",
0,
CODEC_ID_AMR_NB,
CODEC_ID_NONE,
amr_write_header,
amr_write_packet,
.name = "amr",
.long_name = NULL_IF_CONFIG_SMALL("3GPP AMR file format"),
.mime_type = "audio/amr",
.extensions = "amr",
.audio_codec = CODEC_ID_AMR_NB,
.video_codec = CODEC_ID_NONE,
.write_header = amr_write_header,
.write_packet = amr_write_packet,
};
#endif

12
libavformat/anm.c
View File

@ -226,10 +226,10 @@ repeat:
}
AVInputFormat ff_anm_demuxer = {
"anm",
NULL_IF_CONFIG_SMALL("Deluxe Paint Animation"),
sizeof(AnmDemuxContext),
probe,
read_header,
read_packet,
.name = "anm",
.long_name = NULL_IF_CONFIG_SMALL("Deluxe Paint Animation"),
.priv_data_size = sizeof(AnmDemuxContext),
.read_probe = probe,
.read_header = read_header,
.read_packet = read_packet,
};

11
libavformat/apc.c
View File

@ -81,10 +81,9 @@ static int apc_read_packet(AVFormatContext *s, AVPacket *pkt)
}
AVInputFormat ff_apc_demuxer = {
"apc",
NULL_IF_CONFIG_SMALL("CRYO APC format"),
0,
apc_probe,
apc_read_header,
apc_read_packet,
.name = "apc",
.long_name = NULL_IF_CONFIG_SMALL("CRYO APC format"),
.read_probe = apc_probe,
.read_header = apc_read_header,
.read_packet = apc_read_packet,
};

16
libavformat/ape.c
View File

@ -405,13 +405,13 @@ static int ape_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp
}
AVInputFormat ff_ape_demuxer = {
"ape",
NULL_IF_CONFIG_SMALL("Monkey's Audio"),
sizeof(APEContext),
ape_probe,
ape_read_header,
ape_read_packet,
ape_read_close,
ape_read_seek,
.name = "ape",
.long_name = NULL_IF_CONFIG_SMALL("Monkey's Audio"),
.priv_data_size = sizeof(APEContext),
.read_probe = ape_probe,
.read_header = ape_read_header,
.read_packet = ape_read_packet,
.read_close = ape_read_close,
.read_seek = ape_read_seek,
.extensions = "ape,apl,mac"
};

16
libavformat/applehttp.c
View File

@ -668,12 +668,12 @@ static int applehttp_probe(AVProbeData *p)
}
AVInputFormat ff_applehttp_demuxer = {
"applehttp",
NULL_IF_CONFIG_SMALL("Apple HTTP Live Streaming format"),
sizeof(AppleHTTPContext),
applehttp_probe,
applehttp_read_header,
applehttp_read_packet,
applehttp_close,
applehttp_read_seek,
.name = "applehttp",
.long_name = NULL_IF_CONFIG_SMALL("Apple HTTP Live Streaming format"),
.priv_data_size = sizeof(AppleHTTPContext),
.read_probe = applehttp_probe,
.read_header = applehttp_read_header,
.read_packet = applehttp_read_packet,
.read_close = applehttp_close,
.read_seek = applehttp_read_seek,
};

18
libavformat/asfdec.c
View File

@ -1282,14 +1282,14 @@ static int asf_read_seek(AVFormatContext *s, int stream_index, int64_t pts, int
}
AVInputFormat ff_asf_demuxer = {
"asf",
NULL_IF_CONFIG_SMALL("ASF format"),
sizeof(ASFContext),
asf_probe,
asf_read_header,
asf_read_packet,
asf_read_close,
asf_read_seek,
asf_read_pts,
.name = "asf",
.long_name = NULL_IF_CONFIG_SMALL("ASF format"),
.priv_data_size = sizeof(ASFContext),
.read_probe = asf_probe,
.read_header = asf_read_header,
.read_packet = asf_read_packet,
.read_close = asf_read_close,
.read_seek = asf_read_seek,
.read_timestamp = asf_read_pts,
.flags = AVFMT_NOBINSEARCH | AVFMT_NOGENSEARCH,
};

44
libavformat/asfenc.c
View File

@ -882,20 +882,20 @@ static int asf_write_trailer(AVFormatContext *s)
#if CONFIG_ASF_MUXER
AVOutputFormat ff_asf_muxer = {
"asf",
NULL_IF_CONFIG_SMALL("ASF format"),
"video/x-ms-asf",
"asf,wmv,wma",
sizeof(ASFContext),
.name = "asf",
.long_name = NULL_IF_CONFIG_SMALL("ASF format"),
.mime_type = "video/x-ms-asf",
.extensions = "asf,wmv,wma",
.priv_data_size = sizeof(ASFContext),
#if CONFIG_LIBMP3LAME
CODEC_ID_MP3,
.audio_codec = CODEC_ID_MP3,
#else
CODEC_ID_MP2,
.audio_codec = CODEC_ID_MP2,
#endif
CODEC_ID_MSMPEG4V3,
asf_write_header,
asf_write_packet,
asf_write_trailer,
.video_codec = CODEC_ID_MSMPEG4V3,
.write_header = asf_write_header,
.write_packet = asf_write_packet,
.write_trailer = asf_write_trailer,
.flags = AVFMT_GLOBALHEADER,
.codec_tag= (const AVCodecTag* const []){codec_asf_bmp_tags, ff_codec_bmp_tags, ff_codec_wav_tags, 0},
};
@ -903,20 +903,20 @@ AVOutputFormat ff_asf_muxer = {
#if CONFIG_ASF_STREAM_MUXER
AVOutputFormat ff_asf_stream_muxer = {
"asf_stream",
NULL_IF_CONFIG_SMALL("ASF format"),
"video/x-ms-asf",
"asf,wmv,wma",
sizeof(ASFContext),
.name = "asf_stream",
.long_name = NULL_IF_CONFIG_SMALL("ASF format"),
.mime_type = "video/x-ms-asf",
.extensions = "asf,wmv,wma",
.priv_data_size = sizeof(ASFContext),
#if CONFIG_LIBMP3LAME
CODEC_ID_MP3,
.audio_codec = CODEC_ID_MP3,
#else
CODEC_ID_MP2,
.audio_codec = CODEC_ID_MP2,
#endif
CODEC_ID_MSMPEG4V3,
asf_write_stream_header,
asf_write_packet,
asf_write_trailer,
.video_codec = CODEC_ID_MSMPEG4V3,
.write_header = asf_write_stream_header,
.write_packet = asf_write_packet,
.write_trailer = asf_write_trailer,
.flags = AVFMT_GLOBALHEADER,
.codec_tag= (const AVCodecTag* const []){codec_asf_bmp_tags, ff_codec_bmp_tags, ff_codec_wav_tags, 0},
};

33
libavformat/au.c
View File

@ -185,30 +185,27 @@ static int au_read_packet(AVFormatContext *s,
#if CONFIG_AU_DEMUXER
AVInputFormat ff_au_demuxer = {
"au",
NULL_IF_CONFIG_SMALL("SUN AU format"),
0,
au_probe,
au_read_header,
au_read_packet,
NULL,
pcm_read_seek,
.name = "au",
.long_name = NULL_IF_CONFIG_SMALL("SUN AU format"),
.read_probe = au_probe,
.read_header = au_read_header,
.read_packet = au_read_packet,
.read_seek = pcm_read_seek,
.codec_tag= (const AVCodecTag* const []){codec_au_tags, 0},
};
#endif
#if CONFIG_AU_MUXER
AVOutputFormat ff_au_muxer = {
"au",
NULL_IF_CONFIG_SMALL("SUN AU format"),
"audio/basic",
"au",
0,
CODEC_ID_PCM_S16BE,
CODEC_ID_NONE,
au_write_header,
au_write_packet,
au_write_trailer,
.name = "au",
.long_name = NULL_IF_CONFIG_SMALL("SUN AU format"),
.mime_type = "audio/basic",
.extensions = "au",
.audio_codec = CODEC_ID_PCM_S16BE,
.video_codec = CODEC_ID_NONE,
.write_header = au_write_header,
.write_packet = au_write_packet,
.write_trailer = au_write_trailer,
.codec_tag= (const AVCodecTag* const []){codec_au_tags, 0},
};
#endif //CONFIG_AU_MUXER

16
libavformat/avidec.c
View File

@ -1446,13 +1446,13 @@ static int avi_probe(AVProbeData *p)
}
AVInputFormat ff_avi_demuxer = {
"avi",
NULL_IF_CONFIG_SMALL("AVI format"),
sizeof(AVIContext),
avi_probe,
avi_read_header,
avi_read_packet,
avi_read_close,
avi_read_seek,
.name = "avi",
.long_name = NULL_IF_CONFIG_SMALL("AVI format"),
.priv_data_size = sizeof(AVIContext),
.read_probe = avi_probe,
.read_header = avi_read_header,
.read_packet = avi_read_packet,
.read_close = avi_read_close,
.read_seek = avi_read_seek,
.priv_class = &demuxer_class,
};

20
libavformat/avienc.c
View File

@ -639,16 +639,16 @@ static int avi_write_trailer(AVFormatContext *s)
}
AVOutputFormat ff_avi_muxer = {
"avi",
NULL_IF_CONFIG_SMALL("AVI format"),
"video/x-msvideo",
"avi",
sizeof(AVIContext),
CODEC_ID_MP2,
CODEC_ID_MPEG4,
avi_write_header,
avi_write_packet,
avi_write_trailer,
.name = "avi",
.long_name = NULL_IF_CONFIG_SMALL("AVI format"),
.mime_type = "video/x-msvideo",
.extensions = "avi",
.priv_data_size = sizeof(AVIContext),
.audio_codec = CODEC_ID_MP2,
.video_codec = CODEC_ID_MPEG4,
.write_header = avi_write_header,
.write_packet = avi_write_packet,
.write_trailer = avi_write_trailer,
.codec_tag= (const AVCodecTag* const []){ff_codec_bmp_tags, ff_codec_wav_tags, 0},
.flags= AVFMT_VARIABLE_FPS,
};

19
libavformat/avisynth.c
View File

@ -208,15 +208,12 @@ static int avisynth_read_seek(AVFormatContext *s, int stream_index, int64_t pts,
}
AVInputFormat ff_avisynth_demuxer = {
"avs",
NULL_IF_CONFIG_SMALL("AVISynth"),
sizeof(AVISynthContext),
NULL,
avisynth_read_header,
avisynth_read_packet,
avisynth_read_close,
avisynth_read_seek,
NULL,
0,
"avs",
.name = "avs",
.long_name = NULL_IF_CONFIG_SMALL("AVISynth"),
.priv_data_size = sizeof(AVISynthContext),
.read_header = avisynth_read_header,
.read_packet = avisynth_read_packet,
.read_close = avisynth_read_close,
.read_seek = avisynth_read_seek,
.extensions = "avs",
};

14
libavformat/avs.c
View File

@ -216,11 +216,11 @@ static int avs_read_close(AVFormatContext * s)
}
AVInputFormat ff_avs_demuxer = {
"avs",
NULL_IF_CONFIG_SMALL("AVS format"),
sizeof(AvsFormat),
avs_probe,
avs_read_header,
avs_read_packet,
avs_read_close,
.name = "avs",
.long_name = NULL_IF_CONFIG_SMALL("AVS format"),
.priv_data_size = sizeof(AvsFormat),
.read_probe = avs_probe,
.read_header = avs_read_header,
.read_packet = avs_read_packet,
.read_close = avs_read_close,
};

12
libavformat/bethsoftvid.c
View File

@ -223,10 +223,10 @@ static int vid_read_packet(AVFormatContext *s,
}
AVInputFormat ff_bethsoftvid_demuxer = {
"bethsoftvid",
NULL_IF_CONFIG_SMALL("Bethesda Softworks VID format"),
sizeof(BVID_DemuxContext),
vid_probe,
vid_read_header,
vid_read_packet,
.name = "bethsoftvid",
.long_name = NULL_IF_CONFIG_SMALL("Bethesda Softworks VID format"),
.priv_data_size = sizeof(BVID_DemuxContext),
.read_probe = vid_probe,
.read_header = vid_read_header,
.read_packet = vid_read_packet,
};

12
libavformat/bfi.c
View File

@ -159,10 +159,10 @@ static int bfi_read_packet(AVFormatContext * s, AVPacket * pkt)
}
AVInputFormat ff_bfi_demuxer = {
"bfi",
NULL_IF_CONFIG_SMALL("Brute Force & Ignorance"),
sizeof(BFIContext),
bfi_probe,
bfi_read_header,
bfi_read_packet,
.name = "bfi",
.long_name = NULL_IF_CONFIG_SMALL("Brute Force & Ignorance"),
.priv_data_size = sizeof(BFIContext),
.read_probe = bfi_probe,
.read_header = bfi_read_header,
.read_packet = bfi_read_packet,
};

15
libavformat/bink.c
View File

@ -264,12 +264,11 @@ static int read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, in
}
AVInputFormat ff_bink_demuxer = {
"bink",
NULL_IF_CONFIG_SMALL("Bink"),
sizeof(BinkDemuxContext),
probe,
read_header,
read_packet,
NULL,
read_seek,
.name = "bink",
.long_name = NULL_IF_CONFIG_SMALL("Bink"),
.priv_data_size = sizeof(BinkDemuxContext),
.read_probe = probe,
.read_header = read_header,
.read_packet = read_packet,
.read_seek = read_seek,
};

12
libavformat/c93.c
View File

@ -193,10 +193,10 @@ static int read_packet(AVFormatContext *s, AVPacket *pkt)
}
AVInputFormat ff_c93_demuxer = {
"c93",
NULL_IF_CONFIG_SMALL("Interplay C93"),
sizeof(C93DemuxContext),
probe,
read_header,
read_packet,
.name = "c93",
.long_name = NULL_IF_CONFIG_SMALL("Interplay C93"),
.priv_data_size = sizeof(C93DemuxContext),
.read_probe = probe,
.read_header = read_header,
.read_packet = read_packet,
};

15
libavformat/cafdec.c
View File

@ -390,13 +390,12 @@ static int read_seek(AVFormatContext *s, int stream_index,
}
AVInputFormat ff_caf_demuxer = {
"caf",
NULL_IF_CONFIG_SMALL("Apple Core Audio Format"),
sizeof(CaffContext),
probe,
read_header,
read_packet,
NULL,
read_seek,
.name = "caf",
.long_name = NULL_IF_CONFIG_SMALL("Apple Core Audio Format"),
.priv_data_size = sizeof(CaffContext),
.read_probe = probe,
.read_header = read_header,
.read_packet = read_packet,
.read_seek = read_seek,
.codec_tag = (const AVCodecTag*[]){ff_codec_caf_tags, 0},
};

10
libavformat/cdg.c
View File

@ -56,11 +56,9 @@ static int read_packet(AVFormatContext *s, AVPacket *pkt)
}
AVInputFormat ff_cdg_demuxer = {
"cdg",
NULL_IF_CONFIG_SMALL("CD Graphics Format"),
0,
NULL,
read_header,
read_packet,
.name = "cdg",
.long_name = NULL_IF_CONFIG_SMALL("CD Graphics Format"),
.read_header = read_header,
.read_packet = read_packet,
.extensions = "cdg"
};

19
libavformat/crcenc.c
View File

@ -55,14 +55,13 @@ static int crc_write_trailer(struct AVFormatContext *s)
}
AVOutputFormat ff_crc_muxer = {
"crc",
NULL_IF_CONFIG_SMALL("CRC testing format"),
NULL,
"",
sizeof(CRCState),
CODEC_ID_PCM_S16LE,
CODEC_ID_RAWVIDEO,
crc_write_header,
crc_write_packet,
crc_write_trailer,
.name = "crc",
.long_name = NULL_IF_CONFIG_SMALL("CRC testing format"),
.extensions = "",
.priv_data_size = sizeof(CRCState),
.audio_codec = CODEC_ID_PCM_S16LE,
.video_codec = CODEC_ID_RAWVIDEO,
.write_header = crc_write_header,
.write_packet = crc_write_packet,
.write_trailer = crc_write_trailer,
};

12
libavformat/daud.c
View File

@ -71,14 +71,10 @@ static int daud_write_packet(struct AVFormatContext *s, AVPacket *pkt)
#if CONFIG_DAUD_DEMUXER
AVInputFormat ff_daud_demuxer = {
"daud",
NULL_IF_CONFIG_SMALL("D-Cinema audio format"),
0,
NULL,
daud_header,
daud_packet,
NULL,
NULL,
.name = "daud",
.long_name = NULL_IF_CONFIG_SMALL("D-Cinema audio format"),
.read_header = daud_header,
.read_packet = daud_packet,
.extensions = "302",
};
#endif

11
libavformat/dfa.c
View File

@ -109,11 +109,10 @@ static int dfa_read_packet(AVFormatContext *s, AVPacket *pkt)
}
AVInputFormat ff_dfa_demuxer = {
"dfa",
NULL_IF_CONFIG_SMALL("Chronomaster DFA"),
0,
dfa_probe,
dfa_read_header,
dfa_read_packet,
.name = "dfa",
.long_name = NULL_IF_CONFIG_SMALL("Chronomaster DFA"),
.read_probe = dfa_probe,
.read_header = dfa_read_header,
.read_packet = dfa_read_packet,
.flags = AVFMT_GENERIC_INDEX,
};

12
libavformat/dsicin.c
View File

@ -217,10 +217,10 @@ static int cin_read_packet(AVFormatContext *s, AVPacket *pkt)
}
AVInputFormat ff_dsicin_demuxer = {
"dsicin",
NULL_IF_CONFIG_SMALL("Delphine Software International CIN format"),
sizeof(CinDemuxContext),
cin_probe,
cin_read_header,
cin_read_packet,
.name = "dsicin",
.long_name = NULL_IF_CONFIG_SMALL("Delphine Software International CIN format"),
.priv_data_size = sizeof(CinDemuxContext),
.read_probe = cin_probe,
.read_header = cin_read_header,
.read_packet = cin_read_packet,
};

11
libavformat/dtsdec.c
View File

@ -66,12 +66,11 @@ static int dts_probe(AVProbeData *p)
}
AVInputFormat ff_dts_demuxer = {
"dts",
NULL_IF_CONFIG_SMALL("raw DTS"),
0,
dts_probe,
ff_raw_audio_read_header,
ff_raw_read_partial_packet,
.name = "dts",
.long_name = NULL_IF_CONFIG_SMALL("raw DTS"),
.read_probe = dts_probe,
.read_header = ff_raw_audio_read_header,
.read_packet = ff_raw_read_partial_packet,
.flags= AVFMT_GENERIC_INDEX,
.extensions = "dts",
.value = CODEC_ID_DTS,

16
libavformat/dv.c
View File

@ -523,14 +523,14 @@ static int dv_probe(AVProbeData *p)
#if CONFIG_DV_DEMUXER
AVInputFormat ff_dv_demuxer = {
"dv",
NULL_IF_CONFIG_SMALL("DV video format"),
sizeof(RawDVContext),
dv_probe,
dv_read_header,
dv_read_packet,
dv_read_close,
dv_read_seek,
.name = "dv",
.long_name = NULL_IF_CONFIG_SMALL("DV video format"),
.priv_data_size = sizeof(RawDVContext),
.read_probe = dv_probe,
.read_header = dv_read_header,
.read_packet = dv_read_packet,
.read_close = dv_read_close,
.read_seek = dv_read_seek,
.extensions = "dv,dif",
};
#endif

19
libavformat/dvenc.c
View File

@ -408,14 +408,13 @@ static int dv_write_trailer(struct AVFormatContext *s)
}
AVOutputFormat ff_dv_muxer = {
"dv",
NULL_IF_CONFIG_SMALL("DV video format"),
NULL,
"dv",
sizeof(DVMuxContext),
CODEC_ID_PCM_S16LE,
CODEC_ID_DVVIDEO,
dv_write_header,
dv_write_packet,
dv_write_trailer,
.name = "dv",
.long_name = NULL_IF_CONFIG_SMALL("DV video format"),
.extensions = "dv",
.priv_data_size = sizeof(DVMuxContext),
.audio_codec = CODEC_ID_PCM_S16LE,
.video_codec = CODEC_ID_DVVIDEO,
.write_header = dv_write_header,
.write_packet = dv_write_packet,
.write_trailer = dv_write_trailer,
};

12
libavformat/dxa.c
View File

@ -213,10 +213,10 @@ static int dxa_read_packet(AVFormatContext *s, AVPacket *pkt)
}
AVInputFormat ff_dxa_demuxer = {
"dxa",
NULL_IF_CONFIG_SMALL("DXA"),
sizeof(DXAContext),
dxa_probe,
dxa_read_header,
dxa_read_packet,
.name = "dxa",
.long_name = NULL_IF_CONFIG_SMALL("DXA"),
.priv_data_size = sizeof(DXAContext),
.read_probe = dxa_probe,
.read_header = dxa_read_header,
.read_packet = dxa_read_packet,
};

12
libavformat/eacdata.c
View File

@ -95,11 +95,11 @@ static int cdata_read_packet(AVFormatContext *s, AVPacket *pkt)
}
AVInputFormat ff_ea_cdata_demuxer = {
"ea_cdata",
NULL_IF_CONFIG_SMALL("Electronic Arts cdata"),
sizeof(CdataDemuxContext),
cdata_probe,
cdata_read_header,
cdata_read_packet,
.name = "ea_cdata",
.long_name = NULL_IF_CONFIG_SMALL("Electronic Arts cdata"),
.priv_data_size = sizeof(CdataDemuxContext),
.read_probe = cdata_probe,
.read_header = cdata_read_header,
.read_packet = cdata_read_packet,
.extensions = "cdata",
};

12
libavformat/electronicarts.c
View File

@ -571,10 +571,10 @@ get_video_packet:
}
AVInputFormat ff_ea_demuxer = {
"ea",
NULL_IF_CONFIG_SMALL("Electronic Arts Multimedia Format"),
sizeof(EaDemuxContext),
ea_probe,
ea_read_header,
ea_read_packet,
.name = "ea",
.long_name = NULL_IF_CONFIG_SMALL("Electronic Arts Multimedia Format"),
.priv_data_size = sizeof(EaDemuxContext),
.read_probe = ea_probe,
.read_header = ea_read_header,
.read_packet = ea_read_packet,
};

16
libavformat/ffmdec.c
View File

@ -508,12 +508,12 @@ static int ffm_probe(AVProbeData *p)
}
AVInputFormat ff_ffm_demuxer = {
"ffm",
NULL_IF_CONFIG_SMALL("FFM (FFserver live feed) format"),
sizeof(FFMContext),
ffm_probe,
ffm_read_header,
ffm_read_packet,
ffm_close,
ffm_seek,
.name = "ffm",
.long_name = NULL_IF_CONFIG_SMALL("FFM (FFserver live feed) format"),
.priv_data_size = sizeof(FFMContext),
.read_probe = ffm_probe,
.read_header = ffm_read_header,
.read_packet = ffm_read_packet,
.read_close = ffm_close,
.read_seek = ffm_seek,
};

21
libavformat/ffmenc.c
View File

@ -241,15 +241,14 @@ static int ffm_write_trailer(AVFormatContext *s)
}
AVOutputFormat ff_ffm_muxer = {
"ffm",
NULL_IF_CONFIG_SMALL("FFM (FFserver live feed) format"),
"",
"ffm",
sizeof(FFMContext),
/* not really used */
CODEC_ID_MP2,
CODEC_ID_MPEG1VIDEO,
ffm_write_header,
ffm_write_packet,
ffm_write_trailer,
.name = "ffm",
.long_name = NULL_IF_CONFIG_SMALL("FFM (FFserver live feed) format"),
.mime_type = "",
.extensions = "ffm",
.priv_data_size = sizeof(FFMContext),
.audio_codec = CODEC_ID_MP2,
.video_codec = CODEC_ID_MPEG1VIDEO,
.write_header = ffm_write_header,
.write_packet = ffm_write_packet,
.write_trailer = ffm_write_trailer,
};

14
libavformat/filmstripdec.c
View File

@ -99,13 +99,11 @@ static int read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, in
}
AVInputFormat ff_filmstrip_demuxer = {
"filmstrip",
NULL_IF_CONFIG_SMALL("Adobe Filmstrip"),
sizeof(FilmstripDemuxContext),
NULL,
read_header,
read_packet,
NULL,
read_seek,
.name = "filmstrip",
.long_name = NULL_IF_CONFIG_SMALL("Adobe Filmstrip"),
.priv_data_size = sizeof(FilmstripDemuxContext),
.read_header = read_header,
.read_packet = read_packet,
.read_seek = read_seek,
.extensions = "flm",
};

19
libavformat/filmstripenc.c
View File

@ -72,14 +72,13 @@ static int write_trailer(AVFormatContext *s)
}
AVOutputFormat ff_filmstrip_muxer = {
"filmstrip",
NULL_IF_CONFIG_SMALL("Adobe Filmstrip"),
NULL,
"flm",
sizeof(FilmstripMuxContext),
CODEC_ID_NONE,
CODEC_ID_RAWVIDEO,
write_header,
write_packet,
write_trailer,
.name = "filmstrip",
.long_name = NULL_IF_CONFIG_SMALL("Adobe Filmstrip"),
.extensions = "flm",
.priv_data_size = sizeof(FilmstripMuxContext),
.audio_codec = CODEC_ID_NONE,
.video_codec = CODEC_ID_RAWVIDEO,
.write_header = write_header,
.write_packet = write_packet,
.write_trailer = write_trailer,
};

11
libavformat/flacdec.c
View File

@ -124,12 +124,11 @@ static int flac_probe(AVProbeData *p)
}
AVInputFormat ff_flac_demuxer = {
"flac",
NULL_IF_CONFIG_SMALL("raw FLAC"),
0,
flac_probe,
flac_read_header,
ff_raw_read_partial_packet,
.name = "flac",
.long_name = NULL_IF_CONFIG_SMALL("raw FLAC"),
.read_probe = flac_probe,
.read_header = flac_read_header,
.read_packet = ff_raw_read_partial_packet,
.flags= AVFMT_GENERIC_INDEX,
.extensions = "flac",
.value = CODEC_ID_FLAC,

19
libavformat/flacenc.c
View File

@ -118,15 +118,14 @@ static int flac_write_packet(struct AVFormatContext *s, AVPacket *pkt)
}
AVOutputFormat ff_flac_muxer = {
"flac",
NULL_IF_CONFIG_SMALL("raw FLAC"),
"audio/x-flac",
"flac",
0,
CODEC_ID_FLAC,
CODEC_ID_NONE,
flac_write_header,
flac_write_packet,
flac_write_trailer,
.name = "flac",
.long_name = NULL_IF_CONFIG_SMALL("raw FLAC"),
.mime_type = "audio/x-flac",
.extensions = "flac",
.audio_codec = CODEC_ID_FLAC,
.video_codec = CODEC_ID_NONE,
.write_header = flac_write_header,
.write_packet = flac_write_packet,
.write_trailer = flac_write_trailer,
.flags= AVFMT_NOTIMESTAMPS,
};

12
libavformat/flic.c
View File

@ -261,10 +261,10 @@ static int flic_read_packet(AVFormatContext *s,
}
AVInputFormat ff_flic_demuxer = {
"flic",
NULL_IF_CONFIG_SMALL("FLI/FLC/FLX animation format"),
sizeof(FlicDemuxContext),
flic_probe,
flic_read_header,
flic_read_packet,
.name = "flic",
.long_name = NULL_IF_CONFIG_SMALL("FLI/FLC/FLX animation format"),
.priv_data_size = sizeof(FlicDemuxContext),
.read_probe = flic_probe,
.read_header = flic_read_header,
.read_packet = flic_read_packet,
};

12
libavformat/flvdec.c
View File

@ -560,12 +560,12 @@ static int flv_read_seek2(AVFormatContext *s, int stream_index,
#endif
AVInputFormat ff_flv_demuxer = {
"flv",
NULL_IF_CONFIG_SMALL("FLV format"),
sizeof(FLVContext),
flv_probe,
flv_read_header,
flv_read_packet,
.name = "flv",
.long_name = NULL_IF_CONFIG_SMALL("FLV format"),
.priv_data_size = sizeof(FLVContext),
.read_probe = flv_probe,
.read_header = flv_read_header,
.read_packet = flv_read_packet,
.read_seek = flv_read_seek,
#if 0
.read_seek2 = flv_read_seek2,

22
libavformat/flvenc.c
View File

@ -446,20 +446,20 @@ static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)
}
AVOutputFormat ff_flv_muxer = {
"flv",
NULL_IF_CONFIG_SMALL("FLV format"),
"video/x-flv",
"flv",
sizeof(FLVContext),
.name = "flv",
.long_name = NULL_IF_CONFIG_SMALL("FLV format"),
.mime_type = "video/x-flv",
.extensions = "flv",
.priv_data_size = sizeof(FLVContext),
#if CONFIG_LIBMP3LAME
CODEC_ID_MP3,
.audio_codec = CODEC_ID_MP3,
#else // CONFIG_LIBMP3LAME
CODEC_ID_ADPCM_SWF,
.audio_codec = CODEC_ID_ADPCM_SWF,
#endif // CONFIG_LIBMP3LAME
CODEC_ID_FLV1,
flv_write_header,
flv_write_packet,
flv_write_trailer,
.video_codec = CODEC_ID_FLV1,
.write_header = flv_write_header,
.write_packet = flv_write_packet,
.write_trailer = flv_write_trailer,
.codec_tag= (const AVCodecTag* const []){flv_video_codec_ids, flv_audio_codec_ids, 0},
.flags= AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS,
};

16
libavformat/framecrcenc.c
View File

@ -34,14 +34,10 @@ static int framecrc_write_packet(struct AVFormatContext *s, AVPacket *pkt)
}
AVOutputFormat ff_framecrc_muxer = {
"framecrc",
NULL_IF_CONFIG_SMALL("framecrc testing format"),
NULL,
"",
0,
CODEC_ID_PCM_S16LE,
CODEC_ID_RAWVIDEO,
NULL,
framecrc_write_packet,
NULL,
.name = "framecrc",
.long_name = NULL_IF_CONFIG_SMALL("framecrc testing format"),
.extensions = "",
.audio_codec = CODEC_ID_PCM_S16LE,
.video_codec = CODEC_ID_RAWVIDEO,
.write_packet = framecrc_write_packet,
};

20
libavformat/gif.c
View File

@ -363,15 +363,15 @@ static const AVClass gif_muxer_class = {
};
AVOutputFormat ff_gif_muxer = {
"gif",
NULL_IF_CONFIG_SMALL("GIF Animation"),
"image/gif",
"gif",
sizeof(GIFContext),
CODEC_ID_NONE,
CODEC_ID_RAWVIDEO,
gif_write_header,
gif_write_packet,
gif_write_trailer,
.name = "gif",
.long_name = NULL_IF_CONFIG_SMALL("GIF Animation"),
.mime_type = "image/gif",
.extensions = "gif",
.priv_data_size = sizeof(GIFContext),
.audio_codec = CODEC_ID_NONE,
.video_codec = CODEC_ID_RAWVIDEO,
.write_header = gif_write_header,
.write_packet = gif_write_packet,
.write_trailer = gif_write_trailer,
.priv_class = &gif_muxer_class,
};

17
libavformat/gxf.c
View File

@ -523,13 +523,12 @@ static int64_t gxf_read_timestamp(AVFormatContext *s, int stream_index,
}
AVInputFormat ff_gxf_demuxer = {
"gxf",
NULL_IF_CONFIG_SMALL("GXF format"),
sizeof(struct gxf_stream_info),
gxf_probe,
gxf_header,
gxf_packet,
NULL,
gxf_seek,
gxf_read_timestamp,
.name = "gxf",
.long_name = NULL_IF_CONFIG_SMALL("GXF format"),
.priv_data_size = sizeof(struct gxf_stream_info),
.read_probe = gxf_probe,
.read_header = gxf_header,
.read_packet = gxf_packet,
.read_seek = gxf_seek,
.read_timestamp = gxf_read_timestamp,
};

23
libavformat/gxfenc.c
View File

@ -943,17 +943,14 @@ static int gxf_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *pk
}
AVOutputFormat ff_gxf_muxer = {
"gxf",
NULL_IF_CONFIG_SMALL("GXF format"),
NULL,
"gxf",
sizeof(GXFContext),
CODEC_ID_PCM_S16LE,
CODEC_ID_MPEG2VIDEO,
gxf_write_header,
gxf_write_packet,
gxf_write_trailer,
0,
NULL,
gxf_interleave_packet,
.name = "gxf",
.long_name = NULL_IF_CONFIG_SMALL("GXF format"),
.extensions = "gxf",
.priv_data_size = sizeof(GXFContext),
.audio_codec = CODEC_ID_PCM_S16LE,
.video_codec = CODEC_ID_MPEG2VIDEO,
.write_header = gxf_write_header,
.write_packet = gxf_write_packet,
.write_trailer = gxf_write_trailer,
.interleave_packet = gxf_interleave_packet,
};

12
libavformat/idcin.c
View File

@ -292,10 +292,10 @@ static int idcin_read_packet(AVFormatContext *s,
}
AVInputFormat ff_idcin_demuxer = {
"idcin",
NULL_IF_CONFIG_SMALL("id Cinematic format"),
sizeof(IdcinDemuxContext),
idcin_probe,
idcin_read_header,
idcin_read_packet,
.name = "idcin",
.long_name = NULL_IF_CONFIG_SMALL("id Cinematic format"),
.priv_data_size = sizeof(IdcinDemuxContext),
.read_probe = idcin_probe,
.read_header = idcin_read_header,
.read_packet = idcin_read_packet,
};

12
libavformat/idroqdec.c
View File

@ -216,10 +216,10 @@ static int roq_read_packet(AVFormatContext *s,
}
AVInputFormat ff_roq_demuxer = {
"RoQ",
NULL_IF_CONFIG_SMALL("id RoQ format"),
sizeof(RoqDemuxContext),
roq_probe,
roq_read_header,
roq_read_packet,
.name = "RoQ",
.long_name = NULL_IF_CONFIG_SMALL("id RoQ format"),
.priv_data_size = sizeof(RoqDemuxContext),
.read_probe = roq_probe,
.read_header = roq_read_header,
.read_packet = roq_read_packet,
};

12
libavformat/iff.c
View File

@ -340,10 +340,10 @@ static int iff_read_packet(AVFormatContext *s,
}
AVInputFormat ff_iff_demuxer = {
"IFF",
NULL_IF_CONFIG_SMALL("IFF format"),
sizeof(IffDemuxContext),
iff_probe,
iff_read_header,
iff_read_packet,
.name = "IFF",
.long_name = NULL_IF_CONFIG_SMALL("IFF format"),
.priv_data_size = sizeof(IffDemuxContext),
.read_probe = iff_probe,
.read_header = iff_read_header,
.read_packet = iff_read_packet,
};

11
libavformat/ingenientdec.c
View File

@ -59,12 +59,11 @@ static int ingenient_read_packet(AVFormatContext *s, AVPacket *pkt)
}
AVInputFormat ff_ingenient_demuxer = {
"ingenient",
NULL_IF_CONFIG_SMALL("raw Ingenient MJPEG"),
sizeof(FFRawVideoDemuxerContext),
NULL,
ff_raw_video_read_header,
ingenient_read_packet,
.name = "ingenient",
.long_name = NULL_IF_CONFIG_SMALL("raw Ingenient MJPEG"),
.priv_data_size = sizeof(FFRawVideoDemuxerContext),
.read_header = ff_raw_video_read_header,
.read_packet = ingenient_read_packet,
.flags= AVFMT_GENERIC_INDEX,
.extensions = "cgi", // FIXME
.value = CODEC_ID_MJPEG,

12
libavformat/ipmovie.c
View File

@ -616,10 +616,10 @@ static int ipmovie_read_packet(AVFormatContext *s,
}
AVInputFormat ff_ipmovie_demuxer = {
"ipmovie",
NULL_IF_CONFIG_SMALL("Interplay MVE format"),
sizeof(IPMVEContext),
ipmovie_probe,
ipmovie_read_header,
ipmovie_read_packet,
.name = "ipmovie",
.long_name = NULL_IF_CONFIG_SMALL("Interplay MVE format"),
.priv_data_size = sizeof(IPMVEContext),
.read_probe = ipmovie_probe,
.read_header = ipmovie_read_header,
.read_packet = ipmovie_read_packet,
};

12
libavformat/iss.c
View File

@ -122,11 +122,11 @@ static int iss_read_packet(AVFormatContext *s, AVPacket *pkt)
}
AVInputFormat ff_iss_demuxer = {
"ISS",
NULL_IF_CONFIG_SMALL("Funcom ISS format"),
sizeof(IssDemuxContext),
iss_probe,
iss_read_header,
iss_read_packet,
.name = "ISS",
.long_name = NULL_IF_CONFIG_SMALL("Funcom ISS format"),
.priv_data_size = sizeof(IssDemuxContext),
.read_probe = iss_probe,
.read_header = iss_read_header,
.read_packet = iss_read_packet,
};

11
libavformat/iv8.c
View File

@ -85,12 +85,11 @@ retry:
}
AVInputFormat ff_iv8_demuxer = {
"iv8",
NULL_IF_CONFIG_SMALL("A format generated by IndigoVision 8000 video server"),
0,
probe,
read_header,
read_packet,
.name = "iv8",
.long_name = NULL_IF_CONFIG_SMALL("A format generated by IndigoVision 8000 video server"),
.read_probe = probe,
.read_header = read_header,
.read_packet = read_packet,
.flags= AVFMT_GENERIC_INDEX,
.value = CODEC_ID_MPEG4,
};

11
libavformat/ivfdec.c
View File

@ -80,12 +80,11 @@ static int read_packet(AVFormatContext *s, AVPacket *pkt)
}
AVInputFormat ff_ivf_demuxer = {
"ivf",
NULL_IF_CONFIG_SMALL("On2 IVF"),
0,
probe,
read_header,
read_packet,
.name = "ivf",
.long_name = NULL_IF_CONFIG_SMALL("On2 IVF"),
.read_probe = probe,
.read_header = read_header,
.read_packet = read_packet,
.flags= AVFMT_GENERIC_INDEX,
.codec_tag = (const AVCodecTag*[]){ff_codec_bmp_tags, 0},
};

36
libavformat/libnut.c
View File

@ -151,16 +151,16 @@ static int nut_write_trailer(AVFormatContext * avf) {
}
AVOutputFormat ff_libnut_muxer = {
"libnut",
"nut format",
"video/x-nut",
"nut",
sizeof(NUTContext),
CODEC_ID_VORBIS,
CODEC_ID_MPEG4,
nut_write_header,
nut_write_packet,
nut_write_trailer,
.name = "libnut",
.long_name = "nut format",
.mime_type = "video/x-nut",
.extensions = "nut",
.priv_data_size = sizeof(NUTContext),
.audio_codec = CODEC_ID_VORBIS,
.video_codec = CODEC_ID_MPEG4,
.write_header = nut_write_header,
.write_packet = nut_write_packet,
.write_trailer = nut_write_trailer,
.flags = AVFMT_GLOBALHEADER,
};
#endif /* CONFIG_LIBNUT_MUXER */
@ -298,13 +298,13 @@ static int nut_read_close(AVFormatContext *s) {
}
AVInputFormat ff_libnut_demuxer = {
"libnut",
NULL_IF_CONFIG_SMALL("NUT format"),
sizeof(NUTContext),
nut_probe,
nut_read_header,
nut_read_packet,
nut_read_close,
nut_read_seek,
.name = "libnut",
.long_name = NULL_IF_CONFIG_SMALL("NUT format"),
.priv_data_size = sizeof(NUTContext),
.read_probe = nut_probe,
.read_header = nut_read_header,
.read_packet = nut_read_packet,
.read_close = nut_read_close,
.read_seek = nut_read_seek,
.extensions = "nut",
};

11
libavformat/lmlm4.c
View File

@ -118,10 +118,9 @@ static int lmlm4_read_packet(AVFormatContext *s, AVPacket *pkt) {
}
AVInputFormat ff_lmlm4_demuxer = {
"lmlm4",
NULL_IF_CONFIG_SMALL("lmlm4 raw format"),
0,
lmlm4_probe,
lmlm4_read_header,
lmlm4_read_packet,
.name = "lmlm4",
.long_name = NULL_IF_CONFIG_SMALL("lmlm4 raw format"),
.read_probe = lmlm4_probe,
.read_header = lmlm4_read_header,
.read_packet = lmlm4_read_packet,
};

16
libavformat/matroskadec.c
View File

@ -2055,12 +2055,12 @@ static int matroska_read_close(AVFormatContext *s)
}
AVInputFormat ff_matroska_demuxer = {
"matroska,webm",
NULL_IF_CONFIG_SMALL("Matroska/WebM file format"),
sizeof(MatroskaDemuxContext),
matroska_probe,
matroska_read_header,
matroska_read_packet,
matroska_read_close,
matroska_read_seek,
.name = "matroska,webm",
.long_name = NULL_IF_CONFIG_SMALL("Matroska/WebM file format"),
.priv_data_size = sizeof(MatroskaDemuxContext),
.read_probe = matroska_probe,
.read_header = matroska_read_header,
.read_packet = matroska_read_packet,
.read_close = matroska_read_close,
.read_seek = matroska_read_seek,
};

60
libavformat/matroskaenc.c
View File

@ -1200,16 +1200,16 @@ static int mkv_write_trailer(AVFormatContext *s)
#if CONFIG_MATROSKA_MUXER
AVOutputFormat ff_matroska_muxer = {
"matroska",
NULL_IF_CONFIG_SMALL("Matroska file format"),
"video/x-matroska",
"mkv",
sizeof(MatroskaMuxContext),
CODEC_ID_MP2,
CODEC_ID_MPEG4,
mkv_write_header,
mkv_write_packet,
mkv_write_trailer,
.name = "matroska",
.long_name = NULL_IF_CONFIG_SMALL("Matroska file format"),
.mime_type = "video/x-matroska",
.extensions = "mkv",
.priv_data_size = sizeof(MatroskaMuxContext),
.audio_codec = CODEC_ID_MP2,
.video_codec = CODEC_ID_MPEG4,
.write_header = mkv_write_header,
.write_packet = mkv_write_packet,
.write_trailer = mkv_write_trailer,
.flags = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS,
.codec_tag = (const AVCodecTag* const []){ff_codec_bmp_tags, ff_codec_wav_tags, 0},
.subtitle_codec = CODEC_ID_SSA,
@ -1218,32 +1218,32 @@ AVOutputFormat ff_matroska_muxer = {
#if CONFIG_WEBM_MUXER
AVOutputFormat ff_webm_muxer = {
"webm",
NULL_IF_CONFIG_SMALL("WebM file format"),
"video/webm",
"webm",
sizeof(MatroskaMuxContext),
CODEC_ID_VORBIS,
CODEC_ID_VP8,
mkv_write_header,
mkv_write_packet,
mkv_write_trailer,
.name = "webm",
.long_name = NULL_IF_CONFIG_SMALL("WebM file format"),
.mime_type = "video/webm",
.extensions = "webm",
.priv_data_size = sizeof(MatroskaMuxContext),
.audio_codec = CODEC_ID_VORBIS,
.video_codec = CODEC_ID_VP8,
.write_header = mkv_write_header,
.write_packet = mkv_write_packet,
.write_trailer = mkv_write_trailer,
.flags = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS | AVFMT_TS_NONSTRICT,
};
#endif
#if CONFIG_MATROSKA_AUDIO_MUXER
AVOutputFormat ff_matroska_audio_muxer = {
"matroska",
NULL_IF_CONFIG_SMALL("Matroska file format"),
"audio/x-matroska",
"mka",
sizeof(MatroskaMuxContext),
CODEC_ID_MP2,
CODEC_ID_NONE,
mkv_write_header,
mkv_write_packet,
mkv_write_trailer,
.name = "matroska",
.long_name = NULL_IF_CONFIG_SMALL("Matroska file format"),
.mime_type = "audio/x-matroska",
.extensions = "mka",
.priv_data_size = sizeof(MatroskaMuxContext),
.audio_codec = CODEC_ID_MP2,
.video_codec = CODEC_ID_NONE,
.write_header = mkv_write_header,
.write_packet = mkv_write_packet,
.write_trailer = mkv_write_trailer,
.flags = AVFMT_GLOBALHEADER,
.codec_tag = (const AVCodecTag* const []){ff_codec_wav_tags, 0},
};

36
libavformat/md5enc.c
View File

@ -66,16 +66,15 @@ static int write_trailer(struct AVFormatContext *s)
}
AVOutputFormat ff_md5_muxer = {
"md5",
NULL_IF_CONFIG_SMALL("MD5 testing format"),
NULL,
"",
PRIVSIZE,
CODEC_ID_PCM_S16LE,
CODEC_ID_RAWVIDEO,
write_header,
write_packet,
write_trailer,
.name = "md5",
.long_name = NULL_IF_CONFIG_SMALL("MD5 testing format"),
.extensions = "",
.priv_data_size = PRIVSIZE,
.audio_codec = CODEC_ID_PCM_S16LE,
.video_codec = CODEC_ID_RAWVIDEO,
.write_header = write_header,
.write_packet = write_packet,
.write_trailer = write_trailer,
};
#endif
@ -96,15 +95,12 @@ static int framemd5_write_packet(struct AVFormatContext *s, AVPacket *pkt)
}
AVOutputFormat ff_framemd5_muxer = {
"framemd5",
NULL_IF_CONFIG_SMALL("Per-frame MD5 testing format"),
NULL,
"",
PRIVSIZE,
CODEC_ID_PCM_S16LE,
CODEC_ID_RAWVIDEO,
NULL,
framemd5_write_packet,
NULL,
.name = "framemd5",
.long_name = NULL_IF_CONFIG_SMALL("Per-frame MD5 testing format"),
.extensions = "",
.priv_data_size = PRIVSIZE,
.audio_codec = CODEC_ID_PCM_S16LE,
.video_codec = CODEC_ID_RAWVIDEO,
.write_packet = framemd5_write_packet,
};
#endif

12
libavformat/mm.c
View File

@ -187,10 +187,10 @@ static int read_packet(AVFormatContext *s,
}
AVInputFormat ff_mm_demuxer = {
"mm",
NULL_IF_CONFIG_SMALL("American Laser Games MM format"),
sizeof(MmDemuxContext),
probe,
read_header,
read_packet,
.name = "mm",
.long_name = NULL_IF_CONFIG_SMALL("American Laser Games MM format"),
.priv_data_size = sizeof(MmDemuxContext),
.read_probe = probe,
.read_header = read_header,
.read_packet = read_packet,
};

35
libavformat/mmf.c
View File

@ -291,27 +291,26 @@ static int mmf_read_packet(AVFormatContext *s,
#if CONFIG_MMF_DEMUXER
AVInputFormat ff_mmf_demuxer = {
"mmf",
NULL_IF_CONFIG_SMALL("Yamaha SMAF"),
sizeof(MMFContext),
mmf_probe,
mmf_read_header,
mmf_read_packet,
NULL,
pcm_read_seek,
.name = "mmf",
.long_name = NULL_IF_CONFIG_SMALL("Yamaha SMAF"),
.priv_data_size = sizeof(MMFContext),
.read_probe = mmf_probe,
.read_header = mmf_read_header,
.read_packet = mmf_read_packet,
.read_seek = pcm_read_seek,
};
#endif
#if CONFIG_MMF_MUXER
AVOutputFormat ff_mmf_muxer = {
"mmf",
NULL_IF_CONFIG_SMALL("Yamaha SMAF"),
"application/vnd.smaf",
"mmf",
sizeof(MMFContext),
CODEC_ID_ADPCM_YAMAHA,
CODEC_ID_NONE,
mmf_write_header,
mmf_write_packet,
mmf_write_trailer,
.name = "mmf",
.long_name = NULL_IF_CONFIG_SMALL("Yamaha SMAF"),
.mime_type = "application/vnd.smaf",
.extensions = "mmf",
.priv_data_size = sizeof(MMFContext),
.audio_codec = CODEC_ID_ADPCM_YAMAHA,
.video_codec = CODEC_ID_NONE,
.write_header = mmf_write_header,
.write_packet = mmf_write_packet,
.write_trailer = mmf_write_trailer,
};
#endif

16
libavformat/mov.c
View File

@ -2630,12 +2630,12 @@ static int mov_read_close(AVFormatContext *s)
}
AVInputFormat ff_mov_demuxer = {
"mov,mp4,m4a,3gp,3g2,mj2",
NULL_IF_CONFIG_SMALL("QuickTime/MPEG-4/Motion JPEG 2000 format"),
sizeof(MOVContext),
mov_probe,
mov_read_header,
mov_read_packet,
mov_read_close,
mov_read_seek,
.name = "mov,mp4,m4a,3gp,3g2,mj2",
.long_name = NULL_IF_CONFIG_SMALL("QuickTime/MPEG-4/Motion JPEG 2000 format"),
.priv_data_size = sizeof(MOVContext),
.read_probe = mov_probe,
.read_header = mov_read_header,
.read_packet = mov_read_packet,
.read_close = mov_read_close,
.read_seek = mov_read_seek,
};

116
libavformat/movenc.c
View File

@ -2351,16 +2351,15 @@ static int mov_write_trailer(AVFormatContext *s)
#if CONFIG_MOV_MUXER
AVOutputFormat ff_mov_muxer = {
"mov",
NULL_IF_CONFIG_SMALL("MOV format"),
NULL,
"mov",
sizeof(MOVMuxContext),
CODEC_ID_AAC,
CODEC_ID_MPEG4,
mov_write_header,
ff_mov_write_packet,
mov_write_trailer,
.name = "mov",
.long_name = NULL_IF_CONFIG_SMALL("MOV format"),
.extensions = "mov",
.priv_data_size = sizeof(MOVMuxContext),
.audio_codec = CODEC_ID_AAC,
.video_codec = CODEC_ID_MPEG4,
.write_header = mov_write_header,
.write_packet = ff_mov_write_packet,
.write_trailer = mov_write_trailer,
.flags = AVFMT_GLOBALHEADER,
.codec_tag = (const AVCodecTag* const []){codec_movvideo_tags, codec_movaudio_tags, 0},
.priv_class = &mov_muxer_class,
@ -2368,16 +2367,15 @@ AVOutputFormat ff_mov_muxer = {
#endif
#if CONFIG_TGP_MUXER
AVOutputFormat ff_tgp_muxer = {
"3gp",
NULL_IF_CONFIG_SMALL("3GP format"),
NULL,
"3gp",
sizeof(MOVMuxContext),
CODEC_ID_AMR_NB,
CODEC_ID_H263,
mov_write_header,
ff_mov_write_packet,
mov_write_trailer,
.name = "3gp",
.long_name = NULL_IF_CONFIG_SMALL("3GP format"),
.extensions = "3gp",
.priv_data_size = sizeof(MOVMuxContext),
.audio_codec = CODEC_ID_AMR_NB,
.video_codec = CODEC_ID_H263,
.write_header = mov_write_header,
.write_packet = ff_mov_write_packet,
.write_trailer = mov_write_trailer,
.flags = AVFMT_GLOBALHEADER,
.codec_tag = (const AVCodecTag* const []){codec_3gp_tags, 0},
.priv_class = &mov_muxer_class,
@ -2385,16 +2383,16 @@ AVOutputFormat ff_tgp_muxer = {
#endif
#if CONFIG_MP4_MUXER
AVOutputFormat ff_mp4_muxer = {
"mp4",
NULL_IF_CONFIG_SMALL("MP4 format"),
"application/mp4",
"mp4",
sizeof(MOVMuxContext),
CODEC_ID_AAC,
CODEC_ID_MPEG4,
mov_write_header,
ff_mov_write_packet,
mov_write_trailer,
.name = "mp4",
.long_name = NULL_IF_CONFIG_SMALL("MP4 format"),
.mime_type = "application/mp4",
.extensions = "mp4",
.priv_data_size = sizeof(MOVMuxContext),
.audio_codec = CODEC_ID_AAC,
.video_codec = CODEC_ID_MPEG4,
.write_header = mov_write_header,
.write_packet = ff_mov_write_packet,
.write_trailer = mov_write_trailer,
.flags = AVFMT_GLOBALHEADER,
.codec_tag = (const AVCodecTag* const []){ff_mp4_obj_type, 0},
.priv_class = &mov_muxer_class,
@ -2402,16 +2400,15 @@ AVOutputFormat ff_mp4_muxer = {
#endif
#if CONFIG_PSP_MUXER
AVOutputFormat ff_psp_muxer = {
"psp",
NULL_IF_CONFIG_SMALL("PSP MP4 format"),
NULL,
"mp4,psp",
sizeof(MOVMuxContext),
CODEC_ID_AAC,
CODEC_ID_MPEG4,
mov_write_header,
ff_mov_write_packet,
mov_write_trailer,
.name = "psp",
.long_name = NULL_IF_CONFIG_SMALL("PSP MP4 format"),
.extensions = "mp4,psp",
.priv_data_size = sizeof(MOVMuxContext),
.audio_codec = CODEC_ID_AAC,
.video_codec = CODEC_ID_MPEG4,
.write_header = mov_write_header,
.write_packet = ff_mov_write_packet,
.write_trailer = mov_write_trailer,
.flags = AVFMT_GLOBALHEADER,
.codec_tag = (const AVCodecTag* const []){ff_mp4_obj_type, 0},
.priv_class = &mov_muxer_class,
@ -2419,16 +2416,15 @@ AVOutputFormat ff_psp_muxer = {
#endif
#if CONFIG_TG2_MUXER
AVOutputFormat ff_tg2_muxer = {
"3g2",
NULL_IF_CONFIG_SMALL("3GP2 format"),
NULL,
"3g2",
sizeof(MOVMuxContext),
CODEC_ID_AMR_NB,
CODEC_ID_H263,
mov_write_header,
ff_mov_write_packet,
mov_write_trailer,
.name = "3g2",
.long_name = NULL_IF_CONFIG_SMALL("3GP2 format"),
.extensions = "3g2",
.priv_data_size = sizeof(MOVMuxContext),
.audio_codec = CODEC_ID_AMR_NB,
.video_codec = CODEC_ID_H263,
.write_header = mov_write_header,
.write_packet = ff_mov_write_packet,
.write_trailer = mov_write_trailer,
.flags = AVFMT_GLOBALHEADER,
.codec_tag = (const AVCodecTag* const []){codec_3gp_tags, 0},
.priv_class = &mov_muxer_class,
@ -2436,16 +2432,16 @@ AVOutputFormat ff_tg2_muxer = {
#endif
#if CONFIG_IPOD_MUXER
AVOutputFormat ff_ipod_muxer = {
"ipod",
NULL_IF_CONFIG_SMALL("iPod H.264 MP4 format"),
"application/mp4",
"m4v,m4a",
sizeof(MOVMuxContext),
CODEC_ID_AAC,
CODEC_ID_H264,
mov_write_header,
ff_mov_write_packet,
mov_write_trailer,
.name = "ipod",
.long_name = NULL_IF_CONFIG_SMALL("iPod H.264 MP4 format"),
.mime_type = "application/mp4",
.extensions = "m4v,m4a",
.priv_data_size = sizeof(MOVMuxContext),
.audio_codec = CODEC_ID_AAC,
.video_codec = CODEC_ID_H264,
.write_header = mov_write_header,
.write_packet = ff_mov_write_packet,
.write_trailer = mov_write_trailer,
.flags = AVFMT_GLOBALHEADER,
.codec_tag = (const AVCodecTag* const []){codec_ipod_tags, 0},
.priv_class = &mov_muxer_class,

11
libavformat/mp3dec.c
View File

@ -188,12 +188,11 @@ static int mp3_read_packet(AVFormatContext *s, AVPacket *pkt)
}
AVInputFormat ff_mp3_demuxer = {
"mp3",
NULL_IF_CONFIG_SMALL("MPEG audio layer 2/3"),
0,
mp3_read_probe,
mp3_read_header,
mp3_read_packet,
.name = "mp3",
.long_name = NULL_IF_CONFIG_SMALL("MPEG audio layer 2/3"),
.read_probe = mp3_read_probe,
.read_header = mp3_read_header,
.read_packet = mp3_read_packet,
.flags= AVFMT_GENERIC_INDEX,
.extensions = "mp2,mp3,m2a", /* XXX: use probe */
};

40
libavformat/mp3enc.c
View File

@ -174,16 +174,14 @@ static int mp2_write_trailer(struct AVFormatContext *s)
#if CONFIG_MP2_MUXER
AVOutputFormat ff_mp2_muxer = {
"mp2",
NULL_IF_CONFIG_SMALL("MPEG audio layer 2"),
"audio/x-mpeg",
"mp2,m2a",
0,
CODEC_ID_MP2,
CODEC_ID_NONE,
NULL,
ff_raw_write_packet,
mp2_write_trailer,
.name = "mp2",
.long_name = NULL_IF_CONFIG_SMALL("MPEG audio layer 2"),
.mime_type = "audio/x-mpeg",
.extensions = "mp2,m2a",
.audio_codec = CODEC_ID_MP2,
.video_codec = CODEC_ID_NONE,
.write_packet = ff_raw_write_packet,
.write_trailer = mp2_write_trailer,
};
#endif
@ -459,17 +457,17 @@ static int mp3_write_trailer(AVFormatContext *s)
}
AVOutputFormat ff_mp3_muxer = {
"mp3",
NULL_IF_CONFIG_SMALL("MPEG audio layer 3"),
"audio/x-mpeg",
"mp3",
sizeof(MP3Context),
CODEC_ID_MP3,
CODEC_ID_NONE,
mp3_write_header,
mp3_write_packet,
mp3_write_trailer,
AVFMT_NOTIMESTAMPS,
.name = "mp3",
.long_name = NULL_IF_CONFIG_SMALL("MPEG audio layer 3"),
.mime_type = "audio/x-mpeg",
.extensions = "mp3",
.priv_data_size = sizeof(MP3Context),
.audio_codec = CODEC_ID_MP3,
.video_codec = CODEC_ID_NONE,
.write_header = mp3_write_header,
.write_packet = mp3_write_packet,
.write_trailer = mp3_write_trailer,
.flags = AVFMT_NOTIMESTAMPS,
.priv_class = &mp3_muxer_class,
};
#endif

16
libavformat/mpc.c
View File

@ -222,13 +222,13 @@ static int mpc_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp
AVInputFormat ff_mpc_demuxer = {
"mpc",
NULL_IF_CONFIG_SMALL("Musepack"),
sizeof(MPCContext),
mpc_probe,
mpc_read_header,
mpc_read_packet,
mpc_read_close,
mpc_read_seek,
.name = "mpc",
.long_name = NULL_IF_CONFIG_SMALL("Musepack"),
.priv_data_size = sizeof(MPCContext),
.read_probe = mpc_probe,
.read_header = mpc_read_header,
.read_packet = mpc_read_packet,
.read_close = mpc_read_close,
.read_seek = mpc_read_seek,
.extensions = "mpc",
};

15
libavformat/mpc8.c
View File

@ -281,12 +281,11 @@ static int mpc8_read_seek(AVFormatContext *s, int stream_index, int64_t timestam
AVInputFormat ff_mpc8_demuxer = {
"mpc8",
NULL_IF_CONFIG_SMALL("Musepack SV8"),
sizeof(MPCContext),
mpc8_probe,
mpc8_read_header,
mpc8_read_packet,
NULL,
mpc8_read_seek,
.name = "mpc8",
.long_name = NULL_IF_CONFIG_SMALL("Musepack SV8"),
.priv_data_size = sizeof(MPCContext),
.read_probe = mpc8_probe,
.read_header = mpc8_read_header,
.read_packet = mpc8_read_packet,
.read_seek = mpc8_read_seek,
};

17
libavformat/mpeg.c
View File

@ -606,14 +606,13 @@ static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index,
}
AVInputFormat ff_mpegps_demuxer = {
"mpeg",
NULL_IF_CONFIG_SMALL("MPEG-PS format"),
sizeof(MpegDemuxContext),
mpegps_probe,
mpegps_read_header,
mpegps_read_packet,
NULL,
NULL, //mpegps_read_seek,
mpegps_read_dts,
.name = "mpeg",
.long_name = NULL_IF_CONFIG_SMALL("MPEG-PS format"),
.priv_data_size = sizeof(MpegDemuxContext),
.read_probe = mpegps_probe,
.read_header = mpegps_read_header,
.read_packet = mpegps_read_packet,
.read_seek = NULL, //mpegps_read_seek,
.read_timestamp = mpegps_read_dts,
.flags = AVFMT_SHOW_IDS|AVFMT_TS_DISCONT,
};

99
libavformat/mpegenc.c
View File

@ -1232,75 +1232,74 @@ static int mpeg_mux_end(AVFormatContext *ctx)
#if CONFIG_MPEG1SYSTEM_MUXER
AVOutputFormat ff_mpeg1system_muxer = {
"mpeg",
NULL_IF_CONFIG_SMALL("MPEG-1 System format"),
"video/mpeg",
"mpg,mpeg",
sizeof(MpegMuxContext),
CODEC_ID_MP2,
CODEC_ID_MPEG1VIDEO,
mpeg_mux_init,
mpeg_mux_write_packet,
mpeg_mux_end,
.name = "mpeg",
.long_name = NULL_IF_CONFIG_SMALL("MPEG-1 System format"),
.mime_type = "video/mpeg",
.extensions = "mpg,mpeg",
.priv_data_size = sizeof(MpegMuxContext),
.audio_codec = CODEC_ID_MP2,
.video_codec = CODEC_ID_MPEG1VIDEO,
.write_header = mpeg_mux_init,
.write_packet = mpeg_mux_write_packet,
.write_trailer = mpeg_mux_end,
};
#endif
#if CONFIG_MPEG1VCD_MUXER
AVOutputFormat ff_mpeg1vcd_muxer = {
"vcd",
NULL_IF_CONFIG_SMALL("MPEG-1 System format (VCD)"),
"video/mpeg",
NULL,
sizeof(MpegMuxContext),
CODEC_ID_MP2,
CODEC_ID_MPEG1VIDEO,
mpeg_mux_init,
mpeg_mux_write_packet,
mpeg_mux_end,
.name = "vcd",
.long_name = NULL_IF_CONFIG_SMALL("MPEG-1 System format (VCD)"),
.mime_type = "video/mpeg",
.priv_data_size = sizeof(MpegMuxContext),
.audio_codec = CODEC_ID_MP2,
.video_codec = CODEC_ID_MPEG1VIDEO,
.write_header = mpeg_mux_init,
.write_packet = mpeg_mux_write_packet,
.write_trailer = mpeg_mux_end,
};
#endif
#if CONFIG_MPEG2VOB_MUXER
AVOutputFormat ff_mpeg2vob_muxer = {
"vob",
NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"),
"video/mpeg",
"vob",
sizeof(MpegMuxContext),
CODEC_ID_MP2,
CODEC_ID_MPEG2VIDEO,
mpeg_mux_init,
mpeg_mux_write_packet,
mpeg_mux_end,
.name = "vob",
.long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"),
.mime_type = "video/mpeg",
.extensions = "vob",
.priv_data_size = sizeof(MpegMuxContext),
.audio_codec = CODEC_ID_MP2,
.video_codec = CODEC_ID_MPEG2VIDEO,
.write_header = mpeg_mux_init,
.write_packet = mpeg_mux_write_packet,
.write_trailer = mpeg_mux_end,
};
#endif
/* Same as mpeg2vob_mux except that the pack size is 2324 */
#if CONFIG_MPEG2SVCD_MUXER
AVOutputFormat ff_mpeg2svcd_muxer = {
"svcd",
NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"),
"video/mpeg",
"vob",
sizeof(MpegMuxContext),
CODEC_ID_MP2,
CODEC_ID_MPEG2VIDEO,
mpeg_mux_init,
mpeg_mux_write_packet,
mpeg_mux_end,
.name = "svcd",
.long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS format (VOB)"),
.mime_type = "video/mpeg",
.extensions = "vob",
.priv_data_size = sizeof(MpegMuxContext),
.audio_codec = CODEC_ID_MP2,
.video_codec = CODEC_ID_MPEG2VIDEO,
.write_header = mpeg_mux_init,
.write_packet = mpeg_mux_write_packet,
.write_trailer = mpeg_mux_end,
};
#endif
/* Same as mpeg2vob_mux except the 'is_dvd' flag is set to produce NAV pkts */
#if CONFIG_MPEG2DVD_MUXER
AVOutputFormat ff_mpeg2dvd_muxer = {
"dvd",
NULL_IF_CONFIG_SMALL("MPEG-2 PS format (DVD VOB)"),
"video/mpeg",
"dvd",
sizeof(MpegMuxContext),
CODEC_ID_MP2,
CODEC_ID_MPEG2VIDEO,
mpeg_mux_init,
mpeg_mux_write_packet,
mpeg_mux_end,
.name = "dvd",
.long_name = NULL_IF_CONFIG_SMALL("MPEG-2 PS format (DVD VOB)"),
.mime_type = "video/mpeg",
.extensions = "dvd",
.priv_data_size = sizeof(MpegMuxContext),
.audio_codec = CODEC_ID_MP2,
.video_codec = CODEC_ID_MPEG2VIDEO,
.write_header = mpeg_mux_init,
.write_packet = mpeg_mux_write_packet,
.write_trailer = mpeg_mux_end,
};
#endif

35
libavformat/mpegts.c
View File

@ -1887,15 +1887,15 @@ void ff_mpegts_parse_close(MpegTSContext *ts)
}
AVInputFormat ff_mpegts_demuxer = {
"mpegts",
NULL_IF_CONFIG_SMALL("MPEG-2 transport stream format"),
sizeof(MpegTSContext),
mpegts_probe,
mpegts_read_header,
mpegts_read_packet,
mpegts_read_close,
read_seek,
mpegts_get_pcr,
.name = "mpegts",
.long_name = NULL_IF_CONFIG_SMALL("MPEG-2 transport stream format"),
.priv_data_size = sizeof(MpegTSContext),
.read_probe = mpegts_probe,
.read_header = mpegts_read_header,
.read_packet = mpegts_read_packet,
.read_close = mpegts_read_close,
.read_seek = read_seek,
.read_timestamp = mpegts_get_pcr,
.flags = AVFMT_SHOW_IDS|AVFMT_TS_DISCONT,
#ifdef USE_SYNCPOINT_SEARCH
.read_seek2 = read_seek2,
@ -1903,15 +1903,14 @@ AVInputFormat ff_mpegts_demuxer = {
};
AVInputFormat ff_mpegtsraw_demuxer = {
"mpegtsraw",
NULL_IF_CONFIG_SMALL("MPEG-2 raw transport stream format"),
sizeof(MpegTSContext),
NULL,
mpegts_read_header,
mpegts_raw_read_packet,
mpegts_read_close,
read_seek,
mpegts_get_pcr,
.name = "mpegtsraw",
.long_name = NULL_IF_CONFIG_SMALL("MPEG-2 raw transport stream format"),
.priv_data_size = sizeof(MpegTSContext),
.read_header = mpegts_read_header,
.read_packet = mpegts_raw_read_packet,
.read_close = mpegts_read_close,
.read_seek = read_seek,
.read_timestamp = mpegts_get_pcr,
.flags = AVFMT_SHOW_IDS|AVFMT_TS_DISCONT,
#ifdef USE_SYNCPOINT_SEARCH
.read_seek2 = read_seek2,

20
libavformat/mpegtsenc.c
View File

@ -1051,15 +1051,15 @@ static int mpegts_write_end(AVFormatContext *s)
}
AVOutputFormat ff_mpegts_muxer = {
"mpegts",
NULL_IF_CONFIG_SMALL("MPEG-2 transport stream format"),
"video/x-mpegts",
"ts,m2t",
sizeof(MpegTSWrite),
CODEC_ID_MP2,
CODEC_ID_MPEG2VIDEO,
mpegts_write_header,
mpegts_write_packet,
mpegts_write_end,
.name = "mpegts",
.long_name = NULL_IF_CONFIG_SMALL("MPEG-2 transport stream format"),
.mime_type = "video/x-mpegts",
.extensions = "ts,m2t",
.priv_data_size = sizeof(MpegTSWrite),
.audio_codec = CODEC_ID_MP2,
.video_codec = CODEC_ID_MPEG2VIDEO,
.write_header = mpegts_write_header,
.write_packet = mpegts_write_packet,
.write_trailer = mpegts_write_end,
.priv_class = &mpegts_muxer_class,
};

19
libavformat/mpjpeg.c
View File

@ -54,14 +54,13 @@ static int mpjpeg_write_trailer(AVFormatContext *s)
}
AVOutputFormat ff_mpjpeg_muxer = {
"mpjpeg",
NULL_IF_CONFIG_SMALL("MIME multipart JPEG format"),
"multipart/x-mixed-replace;boundary=" BOUNDARY_TAG,
"mjpg",
0,
CODEC_ID_NONE,
CODEC_ID_MJPEG,
mpjpeg_write_header,
mpjpeg_write_packet,
mpjpeg_write_trailer,
.name = "mpjpeg",
.long_name = NULL_IF_CONFIG_SMALL("MIME multipart JPEG format"),
.mime_type = "multipart/x-mixed-replace;boundary=" BOUNDARY_TAG,
.extensions = "mjpg",
.audio_codec = CODEC_ID_NONE,
.video_codec = CODEC_ID_MJPEG,
.write_header = mpjpeg_write_header,
.write_packet = mpjpeg_write_packet,
.write_trailer = mpjpeg_write_trailer,
};

11
libavformat/msnwc_tcp.c
View File

@ -131,10 +131,9 @@ static int msnwc_tcp_read_packet(AVFormatContext *ctx, AVPacket *pkt)
}
AVInputFormat ff_msnwc_tcp_demuxer = {
"msnwctcp",
NULL_IF_CONFIG_SMALL("MSN TCP Webcam stream"),
0,
msnwc_tcp_probe,
msnwc_tcp_read_header,
msnwc_tcp_read_packet,
.name = "msnwctcp",
.long_name = NULL_IF_CONFIG_SMALL("MSN TCP Webcam stream"),
.read_probe = msnwc_tcp_probe,
.read_header = msnwc_tcp_read_header,
.read_packet = msnwc_tcp_read_packet,
};

12
libavformat/mtv.c
View File

@ -197,10 +197,10 @@ static int mtv_read_packet(AVFormatContext *s, AVPacket *pkt)
}
AVInputFormat ff_mtv_demuxer = {
"MTV",
NULL_IF_CONFIG_SMALL("MTV format"),
sizeof(MTVDemuxContext),
mtv_probe,
mtv_read_header,
mtv_read_packet,
.name = "MTV",
.long_name = NULL_IF_CONFIG_SMALL("MTV format"),
.priv_data_size = sizeof(MTVDemuxContext),
.read_probe = mtv_probe,
.read_header = mtv_read_header,
.read_packet = mtv_read_packet,
};

11
libavformat/mvi.c
View File

@ -124,11 +124,10 @@ static int read_packet(AVFormatContext *s, AVPacket *pkt)
}
AVInputFormat ff_mvi_demuxer = {
"mvi",
NULL_IF_CONFIG_SMALL("Motion Pixels MVI format"),
sizeof(MviDemuxContext),
NULL,
read_header,
read_packet,
.name = "mvi",
.long_name = NULL_IF_CONFIG_SMALL("Motion Pixels MVI format"),
.priv_data_size = sizeof(MviDemuxContext),
.read_header = read_header,
.read_packet = read_packet,
.extensions = "mvi"
};

16
libavformat/mxfdec.c
View File

@ -1016,12 +1016,12 @@ static int mxf_read_seek(AVFormatContext *s, int stream_index, int64_t sample_ti
}
AVInputFormat ff_mxf_demuxer = {
"mxf",
NULL_IF_CONFIG_SMALL("Material eXchange Format"),
sizeof(MXFContext),
mxf_probe,
mxf_read_header,
mxf_read_packet,
mxf_read_close,
mxf_read_seek,
.name = "mxf",
.long_name = NULL_IF_CONFIG_SMALL("Material eXchange Format"),
.priv_data_size = sizeof(MXFContext),
.read_probe = mxf_probe,
.read_header = mxf_read_header,
.read_packet = mxf_read_packet,
.read_close = mxf_read_close,
.read_seek = mxf_read_seek,
};

49
libavformat/mxfenc.c
View File

@ -1890,33 +1890,30 @@ static int mxf_interleave(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int
}
AVOutputFormat ff_mxf_muxer = {
"mxf",
NULL_IF_CONFIG_SMALL("Material eXchange Format"),
"application/mxf",
"mxf",
sizeof(MXFContext),
CODEC_ID_PCM_S16LE,
CODEC_ID_MPEG2VIDEO,
mxf_write_header,
mxf_write_packet,
mxf_write_footer,
AVFMT_NOTIMESTAMPS,
NULL,
mxf_interleave,
.name = "mxf",
.long_name = NULL_IF_CONFIG_SMALL("Material eXchange Format"),
.mime_type = "application/mxf",
.extensions = "mxf",
.priv_data_size = sizeof(MXFContext),
.audio_codec = CODEC_ID_PCM_S16LE,
.video_codec = CODEC_ID_MPEG2VIDEO,
.write_header = mxf_write_header,
.write_packet = mxf_write_packet,
.write_trailer = mxf_write_footer,
.flags = AVFMT_NOTIMESTAMPS,
.interleave_packet = mxf_interleave,
};
AVOutputFormat ff_mxf_d10_muxer = {
"mxf_d10",
NULL_IF_CONFIG_SMALL("Material eXchange Format, D-10 Mapping"),
"application/mxf",
NULL,
sizeof(MXFContext),
CODEC_ID_PCM_S16LE,
CODEC_ID_MPEG2VIDEO,
mxf_write_header,
mxf_write_packet,
mxf_write_footer,
AVFMT_NOTIMESTAMPS,
NULL,
mxf_interleave,
.name = "mxf_d10",
.long_name = NULL_IF_CONFIG_SMALL("Material eXchange Format, D-10 Mapping"),
.mime_type = "application/mxf",
.priv_data_size = sizeof(MXFContext),
.audio_codec = CODEC_ID_PCM_S16LE,
.video_codec = CODEC_ID_MPEG2VIDEO,
.write_header = mxf_write_header,
.write_packet = mxf_write_packet,
.write_trailer = mxf_write_footer,
.flags = AVFMT_NOTIMESTAMPS,
.interleave_packet = mxf_interleave,
};

11
libavformat/ncdec.c
View File

@ -91,11 +91,10 @@ static int nc_read_packet(AVFormatContext *s, AVPacket *pkt)
}
AVInputFormat ff_nc_demuxer = {
"nc",
NULL_IF_CONFIG_SMALL("NC camera feed format"),
0,
nc_probe,
nc_read_header,
nc_read_packet,
.name = "nc",
.long_name = NULL_IF_CONFIG_SMALL("NC camera feed format"),
.read_probe = nc_probe,
.read_header = nc_read_header,
.read_packet = nc_read_packet,
.extensions = "v",
};

16
libavformat/nsvdec.c
View File

@ -770,12 +770,12 @@ static int nsv_probe(AVProbeData *p)
}
AVInputFormat ff_nsv_demuxer = {
"nsv",
NULL_IF_CONFIG_SMALL("Nullsoft Streaming Video"),
sizeof(NSVContext),
nsv_probe,
nsv_read_header,
nsv_read_packet,
nsv_read_close,
nsv_read_seek,
.name = "nsv",
.long_name = NULL_IF_CONFIG_SMALL("Nullsoft Streaming Video"),
.priv_data_size = sizeof(NSVContext),
.read_probe = nsv_probe,
.read_header = nsv_read_header,
.read_packet = nsv_read_packet,
.read_close = nsv_read_close,
.read_seek = nsv_read_seek,
};

14
libavformat/nullenc.c
View File

@ -27,14 +27,10 @@ static int null_write_packet(struct AVFormatContext *s, AVPacket *pkt)
}
AVOutputFormat ff_null_muxer = {
"null",
NULL_IF_CONFIG_SMALL("raw null video format"),
NULL,
NULL,
0,
AV_NE(CODEC_ID_PCM_S16BE, CODEC_ID_PCM_S16LE),
CODEC_ID_RAWVIDEO,
NULL,
null_write_packet,
.name = "null",
.long_name = NULL_IF_CONFIG_SMALL("raw null video format"),
.audio_codec = AV_NE(CODEC_ID_PCM_S16BE, CODEC_ID_PCM_S16LE),
.video_codec = CODEC_ID_RAWVIDEO,
.write_packet = null_write_packet,
.flags = AVFMT_NOFILE | AVFMT_RAWPICTURE | AVFMT_NOTIMESTAMPS,
};

16
libavformat/nutdec.c
View File

@ -924,14 +924,14 @@ static int nut_read_close(AVFormatContext *s)
#if CONFIG_NUT_DEMUXER
AVInputFormat ff_nut_demuxer = {
"nut",
NULL_IF_CONFIG_SMALL("NUT format"),
sizeof(NUTContext),
nut_probe,
nut_read_header,
nut_read_packet,
nut_read_close,
read_seek,
.name = "nut",
.long_name = NULL_IF_CONFIG_SMALL("NUT format"),
.priv_data_size = sizeof(NUTContext),
.read_probe = nut_probe,
.read_header = nut_read_header,
.read_packet = nut_read_packet,
.read_close = nut_read_close,
.read_seek = read_seek,
.extensions = "nut",
.codec_tag = (const AVCodecTag * const []) { ff_codec_bmp_tags, ff_nut_video_tags, ff_codec_wav_tags, ff_nut_subtitle_tags, 0 },
};

24
libavformat/nutenc.c
View File

@ -862,22 +862,22 @@ static int write_trailer(AVFormatContext *s){
}
AVOutputFormat ff_nut_muxer = {
"nut",
NULL_IF_CONFIG_SMALL("NUT format"),
"video/x-nut",
"nut",
sizeof(NUTContext),
.name = "nut",
.long_name = NULL_IF_CONFIG_SMALL("NUT format"),
.mime_type = "video/x-nut",
.extensions = "nut",
.priv_data_size = sizeof(NUTContext),
#if CONFIG_LIBVORBIS
CODEC_ID_VORBIS,
.audio_codec = CODEC_ID_VORBIS,
#elif CONFIG_LIBMP3LAME
CODEC_ID_MP3,
.audio_codec = CODEC_ID_MP3,
#else
CODEC_ID_MP2,
.audio_codec = CODEC_ID_MP2,
#endif
CODEC_ID_MPEG4,
write_header,
write_packet,
write_trailer,
.video_codec = CODEC_ID_MPEG4,
.write_header = write_header,
.write_packet = write_packet,
.write_trailer = write_trailer,
.flags = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS,
.codec_tag = (const AVCodecTag * const []){ ff_codec_bmp_tags, ff_nut_video_tags, ff_codec_wav_tags, ff_nut_subtitle_tags, 0 },
};

14
libavformat/nuv.c
View File

@ -259,13 +259,11 @@ static int nuv_packet(AVFormatContext *s, AVPacket *pkt) {
}
AVInputFormat ff_nuv_demuxer = {
"nuv",
NULL_IF_CONFIG_SMALL("NuppelVideo format"),
sizeof(NUVContext),
nuv_probe,
nuv_header,
nuv_packet,
NULL,
NULL,
.name = "nuv",
.long_name = NULL_IF_CONFIG_SMALL("NuppelVideo format"),
.priv_data_size = sizeof(NUVContext),
.read_probe = nuv_probe,
.read_header = nuv_header,
.read_packet = nuv_packet,
.flags = AVFMT_GENERIC_INDEX,
};

20
libavformat/oggenc.c
View File

@ -525,15 +525,15 @@ static int ogg_write_trailer(AVFormatContext *s)
}
AVOutputFormat ff_ogg_muxer = {
"ogg",
NULL_IF_CONFIG_SMALL("Ogg"),
"application/ogg",
"ogg,ogv,spx",
sizeof(OGGContext),
CODEC_ID_FLAC,
CODEC_ID_THEORA,
ogg_write_header,
ogg_write_packet,
ogg_write_trailer,
.name = "ogg",
.long_name = NULL_IF_CONFIG_SMALL("Ogg"),
.mime_type = "application/ogg",
.extensions = "ogg,ogv,spx",
.priv_data_size = sizeof(OGGContext),
.audio_codec = CODEC_ID_FLAC,
.video_codec = CODEC_ID_THEORA,
.write_header = ogg_write_header,
.write_packet = ogg_write_packet,
.write_trailer = ogg_write_trailer,
.priv_class = &ogg_muxer_class,
};

Some files were not shown because too many files have changed in this diff Show More