virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2024-12-23 12:43:46 +02:00
Code Issues Releases Activity

changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility

Browse Source 
Originally committed as revision 4453 to svn://svn.ffmpeg.org/ffmpeg/trunk
This commit is contained in:
Michael Niedermayer 2005-07-17 22:24:36 +00:00
parent 4c1a012e9c
commit 01f4895c68
56 changed files with 1023 additions and 1024 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

152
ffmpeg.c
View File

@ -493,7 +493,7 @@ static void do_audio_out(AVFormatContext *s,
const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
int size_out, frame_bytes, ret;
AVCodecContext *enc= &ost->st->codec;
AVCodecContext *enc= ost->st->codec;
/* SC: dynamic allocation of buffers */
if (!audio_buf)
@ -505,9 +505,9 @@ static void do_audio_out(AVFormatContext *s,
if(audio_sync_method){
double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
- fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2);
double idelta= delta*ist->st->codec.sample_rate / enc->sample_rate;
int byte_delta= ((int)idelta)*2*ist->st->codec.channels;
- fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2);
double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
//FIXME resample delay
if(fabs(delta) > 50){
@ -542,19 +542,19 @@ static void do_audio_out(AVFormatContext *s,
assert(ost->audio_resample);
if(verbose > 2)
fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
// fprintf(stderr, "drift:%f len:%d opts:%lld ipts:%lld fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2));
// fprintf(stderr, "drift:%f len:%d opts:%lld ipts:%lld fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2));
av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
}
}
}else
ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
- fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2); //FIXME wrong
- fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2); //FIXME wrong
if (ost->audio_resample) {
buftmp = audio_buf;
size_out = audio_resample(ost->resample,
(short *)buftmp, (short *)buf,
size / (ist->st->codec.channels * 2));
size / (ist->st->codec->channels * 2));
size_out = size_out * enc->channels * 2;
} else {
buftmp = buf;
@ -625,7 +625,7 @@ static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void
AVPicture picture_tmp;
uint8_t *buf = 0;
dec = &ist->st->codec;
dec = ist->st->codec;
/* deinterlace : must be done before any resize */
if (do_deinterlace || using_vhook) {
@ -721,7 +721,7 @@ static void do_subtitle_out(AVFormatContext *s,
return;
}
enc = &ost->st->codec;
enc = ost->st->codec;
if (!subtitle_out) {
subtitle_out = av_malloc(subtitle_out_max_size);
@ -775,8 +775,8 @@ static void do_video_out(AVFormatContext *s,
avcodec_get_frame_defaults(&picture_format_temp);
avcodec_get_frame_defaults(&picture_crop_temp);
enc = &ost->st->codec;
dec = &ist->st->codec;
enc = ost->st->codec;
dec = ist->st->codec;
/* by default, we output a single frame */
nb_frames = 1;
@ -1049,7 +1049,7 @@ static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
}
ti = MAXINT64;
enc = &ost->st->codec;
enc = ost->st->codec;
if (enc->codec_type == CODEC_TYPE_VIDEO) {
frame_number = ost->frame_number;
fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
@ -1107,7 +1107,7 @@ static void print_report(AVFormatContext **output_files,
for(i=0;i<nb_ostreams;i++) {
ost = ost_table[i];
os = output_files[ost->file_index];
enc = &ost->st->codec;
enc = ost->st->codec;
if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
enc->coded_frame->quality/(float)FF_QP2LAMBDA);
@ -1220,13 +1220,13 @@ static int output_packet(AVInputStream *ist, int ist_index,
data_size = 0;
subtitle_to_free = NULL;
if (ist->decoding_needed) {
switch(ist->st->codec.codec_type) {
switch(ist->st->codec->codec_type) {
case CODEC_TYPE_AUDIO:{
if(pkt)
samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
/* XXX: could avoid copy if PCM 16 bits with same
endianness as CPU */
ret = avcodec_decode_audio(&ist->st->codec, samples, &data_size,
ret = avcodec_decode_audio(ist->st->codec, samples, &data_size,
ptr, len);
if (ret < 0)
goto fail_decode;
@ -1240,14 +1240,14 @@ static int output_packet(AVInputStream *ist, int ist_index,
}
data_buf = (uint8_t *)samples;
ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
(ist->st->codec.sample_rate * ist->st->codec.channels);
(ist->st->codec->sample_rate * ist->st->codec->channels);
break;}
case CODEC_TYPE_VIDEO:
data_size = (ist->st->codec.width * ist->st->codec.height * 3) / 2;
data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
/* XXX: allocate picture correctly */
avcodec_get_frame_defaults(&picture);
ret = avcodec_decode_video(&ist->st->codec,
ret = avcodec_decode_video(ist->st->codec,
&picture, &got_picture, ptr, len);
ist->st->quality= picture.quality;
if (ret < 0)
@ -1256,15 +1256,15 @@ static int output_packet(AVInputStream *ist, int ist_index,
/* no picture yet */
goto discard_packet;
}
if (ist->st->codec.time_base.num != 0) {
if (ist->st->codec->time_base.num != 0) {
ist->next_pts += ((int64_t)AV_TIME_BASE *
ist->st->codec.time_base.num) /
ist->st->codec.time_base.den;
ist->st->codec->time_base.num) /
ist->st->codec->time_base.den;
}
len = 0;
break;
case CODEC_TYPE_SUBTITLE:
ret = avcodec_decode_subtitle(&ist->st->codec,
ret = avcodec_decode_subtitle(ist->st->codec,
&subtitle, &got_subtitle, ptr, len);
if (ret < 0)
goto fail_decode;
@ -1278,16 +1278,16 @@ static int output_packet(AVInputStream *ist, int ist_index,
goto fail_decode;
}
} else {
switch(ist->st->codec.codec_type) {
switch(ist->st->codec->codec_type) {
case CODEC_TYPE_AUDIO:
ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec.frame_size) /
(ist->st->codec.sample_rate * ist->st->codec.channels);
ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
(ist->st->codec->sample_rate * ist->st->codec->channels);
break;
case CODEC_TYPE_VIDEO:
if (ist->st->codec.time_base.num != 0) {
if (ist->st->codec->time_base.num != 0) {
ist->next_pts += ((int64_t)AV_TIME_BASE *
ist->st->codec.time_base.num) /
ist->st->codec.time_base.den;
ist->st->codec->time_base.num) /
ist->st->codec->time_base.den;
}
break;
}
@ -1298,13 +1298,13 @@ static int output_packet(AVInputStream *ist, int ist_index,
}
buffer_to_free = NULL;
if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO) {
if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
pre_process_video_frame(ist, (AVPicture *)&picture,
&buffer_to_free);
}
// preprocess audio (volume)
if (ist->st->codec.codec_type == CODEC_TYPE_AUDIO) {
if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
if (audio_volume != 256) {
short *volp;
volp = samples;
@ -1318,8 +1318,8 @@ static int output_packet(AVInputStream *ist, int ist_index,
}
/* frame rate emulation */
if (ist->st->codec.rate_emu) {
int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec.time_base.num, 1000000, ist->st->codec.time_base.den);
if (ist->st->codec->rate_emu) {
int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
int64_t now = av_gettime() - ist->start;
if (pts > now)
usleep(pts - now);
@ -1331,8 +1331,8 @@ static int output_packet(AVInputStream *ist, int ist_index,
/* mpeg PTS deordering : if it is a P or I frame, the PTS
is the one of the next displayed one */
/* XXX: add mpeg4 too ? */
if (ist->st->codec.codec_id == CODEC_ID_MPEG1VIDEO) {
if (ist->st->codec.pict_type != B_TYPE) {
if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
if (ist->st->codec->pict_type != B_TYPE) {
int64_t tmp;
tmp = ist->last_ip_pts;
ist->last_ip_pts = ist->frac_pts.val;
@ -1360,7 +1360,7 @@ static int output_packet(AVInputStream *ist, int ist_index,
//ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
if (ost->encoding_needed) {
switch(ost->st->codec.codec_type) {
switch(ost->st->codec->codec_type) {
case CODEC_TYPE_AUDIO:
do_audio_out(os, ost, ist, data_buf, data_size);
break;
@ -1386,12 +1386,12 @@ static int output_packet(AVInputStream *ist, int ist_index,
/* force the input stream PTS */
avcodec_get_frame_defaults(&avframe);
ost->st->codec.coded_frame= &avframe;
ost->st->codec->coded_frame= &avframe;
avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO)
if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
audio_size += data_size;
else if (ost->st->codec.codec_type == CODEC_TYPE_VIDEO) {
else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
video_size += data_size;
ost->sync_opts++;
}
@ -1411,10 +1411,10 @@ static int output_packet(AVInputStream *ist, int ist_index,
opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
}
opkt.flags= pkt->flags;
if(av_parser_change(ist->st->parser, &ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
opkt.destruct= av_destruct_packet;
av_interleaved_write_frame(os, &opkt);
ost->st->codec.frame_number++;
ost->st->codec->frame_number++;
ost->frame_number++;
av_free_packet(&opkt);
}
@ -1441,12 +1441,12 @@ static int output_packet(AVInputStream *ist, int ist_index,
for(i=0;i<nb_ostreams;i++) {
ost = ost_table[i];
if (ost->source_index == ist_index) {
AVCodecContext *enc= &ost->st->codec;
AVCodecContext *enc= ost->st->codec;
os = output_files[ost->file_index];
if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
continue;
if(ost->st->codec.codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
continue;
if (ost->encoding_needed) {
@ -1455,7 +1455,7 @@ static int output_packet(AVInputStream *ist, int ist_index,
av_init_packet(&pkt);
pkt.stream_index= ost->index;
switch(ost->st->codec.codec_type) {
switch(ost->st->codec->codec_type) {
case CODEC_TYPE_AUDIO:
ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
audio_size += ret;
@ -1546,7 +1546,7 @@ static int av_encode(AVFormatContext **output_files,
ist->discard = 1; /* the stream is discarded by default
(changed later) */
if (ist->st->codec.rate_emu) {
if (ist->st->codec->rate_emu) {
ist->start = av_gettime();
ist->frame = 0;
}
@ -1607,7 +1607,7 @@ static int av_encode(AVFormatContext **output_files,
stream_maps[n-1].stream_index;
/* Sanity check that the stream types match */
if (ist_table[ost->source_index]->st->codec.codec_type != ost->st->codec.codec_type) {
if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
ost->file_index, ost->index);
@ -1620,7 +1620,7 @@ static int av_encode(AVFormatContext **output_files,
for(j=0;j<nb_istreams;j++) {
ist = ist_table[j];
if (ist->discard &&
ist->st->codec.codec_type == ost->st->codec.codec_type) {
ist->st->codec->codec_type == ost->st->codec->codec_type) {
ost->source_index = j;
found = 1;
break;
@ -1631,7 +1631,7 @@ static int av_encode(AVFormatContext **output_files,
/* try again and reuse existing stream */
for(j=0;j<nb_istreams;j++) {
ist = ist_table[j];
if (ist->st->codec.codec_type == ost->st->codec.codec_type) {
if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
ost->source_index = j;
found = 1;
}
@ -1656,8 +1656,8 @@ static int av_encode(AVFormatContext **output_files,
ost = ost_table[i];
ist = ist_table[ost->source_index];
codec = &ost->st->codec;
icodec = &ist->st->codec;
codec = ost->st->codec;
icodec = ist->st->codec;
if (ost->st->stream_copy) {
/* if stream_copy is selected, no need to decode or encode */
@ -1773,8 +1773,8 @@ static int av_encode(AVFormatContext **output_files,
goto fail;
ost->img_resample_ctx = img_resample_full_init(
ost->st->codec.width, ost->st->codec.height,
ist->st->codec.width, ist->st->codec.height,
ost->st->codec->width, ost->st->codec->height,
ist->st->codec->width, ist->st->codec->height,
frame_topBand, frame_bottomBand,
frame_leftBand, frame_rightBand,
frame_padtop, frame_padbottom,
@ -1877,18 +1877,18 @@ static int av_encode(AVFormatContext **output_files,
ost = ost_table[i];
if (ost->encoding_needed) {
AVCodec *codec;
codec = avcodec_find_encoder(ost->st->codec.codec_id);
codec = avcodec_find_encoder(ost->st->codec->codec_id);
if (!codec) {
fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
ost->file_index, ost->index);
exit(1);
}
if (avcodec_open(&ost->st->codec, codec) < 0) {
if (avcodec_open(ost->st->codec, codec) < 0) {
fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
ost->file_index, ost->index);
exit(1);
}
extra_size += ost->st->codec.extradata_size;
extra_size += ost->st->codec->extradata_size;
}
}
@ -1897,19 +1897,19 @@ static int av_encode(AVFormatContext **output_files,
ist = ist_table[i];
if (ist->decoding_needed) {
AVCodec *codec;
codec = avcodec_find_decoder(ist->st->codec.codec_id);
codec = avcodec_find_decoder(ist->st->codec->codec_id);
if (!codec) {
fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
ist->st->codec.codec_id, ist->file_index, ist->index);
ist->st->codec->codec_id, ist->file_index, ist->index);
exit(1);
}
if (avcodec_open(&ist->st->codec, codec) < 0) {
if (avcodec_open(ist->st->codec, codec) < 0) {
fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
ist->file_index, ist->index);
exit(1);
}
//if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO)
// ist->st->codec.flags |= CODEC_FLAG_REPEAT_FIELD;
//if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
// ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
}
}
@ -2010,8 +2010,8 @@ static int av_encode(AVFormatContext **output_files,
ost = ost_table[i];
os = output_files[ost->file_index];
ist = ist_table[ost->source_index];
if(ost->st->codec.codec_type == CODEC_TYPE_VIDEO)
opts = ost->sync_opts * av_q2d(ost->st->codec.time_base);
if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
else
opts = ost->st->pts.val * av_q2d(ost->st->time_base);
ipts = (double)ist->pts;
@ -2025,7 +2025,7 @@ static int av_encode(AVFormatContext **output_files,
if(!input_sync) file_index = ist->file_index;
}
}
if(ost->frame_number >= max_frames[ost->st->codec.codec_type]){
if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
file_index= -1;
break;
}
@ -2067,7 +2067,7 @@ static int av_encode(AVFormatContext **output_files,
if (ist->discard)
goto discard_packet;
// fprintf(stderr, "next:%lld dts:%lld off:%lld %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec.codec_type);
// fprintf(stderr, "next:%lld dts:%lld off:%lld %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
if(ABS(delta) > 10LL*AV_TIME_BASE && !copy_ts){
@ -2123,8 +2123,8 @@ static int av_encode(AVFormatContext **output_files,
for(i=0;i<nb_ostreams;i++) {
ost = ost_table[i];
if (ost->encoding_needed) {
av_freep(&ost->st->codec.stats_in);
avcodec_close(&ost->st->codec);
av_freep(&ost->st->codec->stats_in);
avcodec_close(ost->st->codec);
}
}
@ -2132,7 +2132,7 @@ static int av_encode(AVFormatContext **output_files,
for(i=0;i<nb_istreams;i++) {
ist = ist_table[i];
if (ist->decoding_needed) {
avcodec_close(&ist->st->codec);
avcodec_close(ist->st->codec);
}
}
@ -3058,7 +3058,7 @@ static void opt_input_file(const char *filename)
/* update the current parameters so that they match the one of the input stream */
for(i=0;i<ic->nb_streams;i++) {
AVCodecContext *enc = &ic->streams[i]->codec;
AVCodecContext *enc = ic->streams[i]->codec;
#if defined(HAVE_THREADS)
if(thread_count>1)
avcodec_thread_init(enc, thread_count);
@ -3154,7 +3154,7 @@ static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
for(j=0;j<nb_input_files;j++) {
ic = input_files[j];
for(i=0;i<ic->nb_streams;i++) {
AVCodecContext *enc = &ic->streams[i]->codec;
AVCodecContext *enc = ic->streams[i]->codec;
switch(enc->codec_type) {
case CODEC_TYPE_AUDIO:
has_audio = 1;
@ -3187,10 +3187,10 @@ static void new_video_stream(AVFormatContext *oc)
}
#if defined(HAVE_THREADS)
if(thread_count>1)
avcodec_thread_init(&st->codec, thread_count);
avcodec_thread_init(st->codec, thread_count);
#endif
video_enc = &st->codec;
video_enc = st->codec;
if(video_codec_tag)
video_enc->codec_tag= video_codec_tag;
@ -3473,10 +3473,10 @@ static void new_audio_stream(AVFormatContext *oc)
}
#if defined(HAVE_THREADS)
if(thread_count>1)
avcodec_thread_init(&st->codec, thread_count);
avcodec_thread_init(st->codec, thread_count);
#endif
audio_enc = &st->codec;
audio_enc = st->codec;
audio_enc->codec_type = CODEC_TYPE_AUDIO;
if(audio_codec_tag)
@ -3535,7 +3535,7 @@ static void opt_new_subtitle_stream(void)
exit(1);
}
subtitle_enc = &st->codec;
subtitle_enc = st->codec;
subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
if (subtitle_stream_copy) {
st->stream_copy = 1;
@ -3732,7 +3732,7 @@ static void prepare_grab(void)
for(j=0;j<nb_output_files;j++) {
oc = output_files[j];
for(i=0;i<oc->nb_streams;i++) {
AVCodecContext *enc = &oc->streams[i]->codec;
AVCodecContext *enc = oc->streams[i]->codec;
switch(enc->codec_type) {
case CODEC_TYPE_AUDIO:
if (enc->sample_rate > ap->sample_rate)
@ -4041,7 +4041,7 @@ static void opt_target(const char *arg)
int i, j;
for(j = 0; j < nb_input_files; j++) {
for(i = 0; i < input_files[j]->nb_streams; i++) {
AVCodecContext *c = &input_files[j]->streams[i]->codec;
AVCodecContext *c = input_files[j]->streams[i]->codec;
if(c->codec_type != CODEC_TYPE_VIDEO)
continue;
fr = c->time_base.den * 1000 / c->time_base.num;

72
ffplay.c
View File

@ -381,24 +381,24 @@ static void video_image_display(VideoState *is)
vp = &is->pictq[is->pictq_rindex];
if (vp->bmp) {
/* XXX: use variable in the frame */
if (is->video_st->codec.sample_aspect_ratio.num == 0)
if (is->video_st->codec->sample_aspect_ratio.num == 0)
aspect_ratio = 0;
else
aspect_ratio = av_q2d(is->video_st->codec.sample_aspect_ratio)
* is->video_st->codec.width / is->video_st->codec.height;;
aspect_ratio = av_q2d(is->video_st->codec->sample_aspect_ratio)
* is->video_st->codec->width / is->video_st->codec->height;;
if (aspect_ratio <= 0.0)
aspect_ratio = (float)is->video_st->codec.width /
(float)is->video_st->codec.height;
aspect_ratio = (float)is->video_st->codec->width /
(float)is->video_st->codec->height;
/* if an active format is indicated, then it overrides the
mpeg format */
#if 0
if (is->video_st->codec.dtg_active_format != is->dtg_active_format) {
is->dtg_active_format = is->video_st->codec.dtg_active_format;
if (is->video_st->codec->dtg_active_format != is->dtg_active_format) {
is->dtg_active_format = is->video_st->codec->dtg_active_format;
printf("dtg_active_format=%d\n", is->dtg_active_format);
}
#endif
#if 0
switch(is->video_st->codec.dtg_active_format) {
switch(is->video_st->codec->dtg_active_format) {
case FF_DTG_AFD_SAME:
default:
/* nothing to do */
@ -469,7 +469,7 @@ static void video_audio_display(VideoState *s)
int16_t time_diff;
/* compute display index : center on currently output samples */
channels = s->audio_st->codec.channels;
channels = s->audio_st->codec->channels;
nb_display_channels = channels;
if (!s->paused) {
n = 2 * channels;
@ -480,7 +480,7 @@ static void video_audio_display(VideoState *s)
the last buffer computation */
if (audio_callback_time) {
time_diff = av_gettime() - audio_callback_time;
delay += (time_diff * s->audio_st->codec.sample_rate) / 1000000;
delay += (time_diff * s->audio_st->codec->sample_rate) / 1000000;
}
delay -= s->width / 2;
@ -567,8 +567,8 @@ static double get_audio_clock(VideoState *is)
hw_buf_size = audio_write_get_buf_size(is);
bytes_per_sec = 0;
if (is->audio_st) {
bytes_per_sec = is->audio_st->codec.sample_rate *
2 * is->audio_st->codec.channels;
bytes_per_sec = is->audio_st->codec->sample_rate *
2 * is->audio_st->codec->channels;
}
if (bytes_per_sec)
pts -= (double)hw_buf_size / bytes_per_sec;
@ -767,7 +767,7 @@ static void alloc_picture(void *opaque)
#if 0
/* XXX: use generic function */
/* XXX: disable overlay if no hardware acceleration or if RGB format */
switch(is->video_st->codec.pix_fmt) {
switch(is->video_st->codec->pix_fmt) {
case PIX_FMT_YUV420P:
case PIX_FMT_YUV422P:
case PIX_FMT_YUV444P:
@ -781,12 +781,12 @@ static void alloc_picture(void *opaque)
break;
}
#endif
vp->bmp = SDL_CreateYUVOverlay(is->video_st->codec.width,
is->video_st->codec.height,
vp->bmp = SDL_CreateYUVOverlay(is->video_st->codec->width,
is->video_st->codec->height,
SDL_YV12_OVERLAY,
screen);
vp->width = is->video_st->codec.width;
vp->height = is->video_st->codec.height;
vp->width = is->video_st->codec->width;
vp->height = is->video_st->codec->height;
SDL_LockMutex(is->pictq_mutex);
vp->allocated = 1;
@ -815,8 +815,8 @@ static int queue_picture(VideoState *is, AVFrame *src_frame, double pts)
/* alloc or resize hardware picture buffer */
if (!vp->bmp ||
vp->width != is->video_st->codec.width ||
vp->height != is->video_st->codec.height) {
vp->width != is->video_st->codec->width ||
vp->height != is->video_st->codec->height) {
SDL_Event event;
vp->allocated = 0;
@ -852,8 +852,8 @@ static int queue_picture(VideoState *is, AVFrame *src_frame, double pts)
pict.linesize[1] = vp->bmp->pitches[2];
pict.linesize[2] = vp->bmp->pitches[1];
img_convert(&pict, dst_pix_fmt,
(AVPicture *)src_frame, is->video_st->codec.pix_fmt,
is->video_st->codec.width, is->video_st->codec.height);
(AVPicture *)src_frame, is->video_st->codec->pix_fmt,
is->video_st->codec->width, is->video_st->codec->height);
/* update the bitmap content */
SDL_UnlockYUVOverlay(vp->bmp);
@ -883,7 +883,7 @@ static int output_picture2(VideoState *is, AVFrame *src_frame, double pts1)
pts = is->video_clock;
}
/* update video clock for next frame */
frame_delay = av_q2d(is->video_st->codec.time_base);
frame_delay = av_q2d(is->video_st->codec->time_base);
/* for MPEG2, the frame can be repeated, so we update the
clock accordingly */
if (src_frame->repeat_pict) {
@ -928,7 +928,7 @@ static int video_thread(void *arg)
pts = av_q2d(is->video_st->time_base)*pkt->dts;
SDL_LockMutex(is->video_decoder_mutex);
len1 = avcodec_decode_video(&is->video_st->codec,
len1 = avcodec_decode_video(is->video_st->codec,
frame, &got_picture,
pkt->data, pkt->size);
SDL_UnlockMutex(is->video_decoder_mutex);
@ -953,7 +953,7 @@ static void update_sample_display(VideoState *is, short *samples, int samples_si
{
int size, len, channels;
channels = is->audio_st->codec.channels;
channels = is->audio_st->codec->channels;
size = samples_size / sizeof(short);
while (size > 0) {
@ -977,7 +977,7 @@ static int synchronize_audio(VideoState *is, short *samples,
int n, samples_size;
double ref_clock;
n = 2 * is->audio_st->codec.channels;
n = 2 * is->audio_st->codec->channels;
samples_size = samples_size1;
/* if not master, then we try to remove or add samples to correct the clock */
@ -999,7 +999,7 @@ static int synchronize_audio(VideoState *is, short *samples,
avg_diff = is->audio_diff_cum * (1.0 - is->audio_diff_avg_coef);
if (fabs(avg_diff) >= is->audio_diff_threshold) {
wanted_size = samples_size + ((int)(diff * is->audio_st->codec.sample_rate) * n);
wanted_size = samples_size + ((int)(diff * is->audio_st->codec->sample_rate) * n);
nb_samples = samples_size / n;
min_size = ((nb_samples * (100 - SAMPLE_CORRECTION_PERCENT_MAX)) / 100) * n;
@ -1057,7 +1057,7 @@ static int audio_decode_frame(VideoState *is, uint8_t *audio_buf, double *pts_pt
/* NOTE: the audio packet can contain several frames */
while (is->audio_pkt_size > 0) {
SDL_LockMutex(is->audio_decoder_mutex);
len1 = avcodec_decode_audio(&is->audio_st->codec,
len1 = avcodec_decode_audio(is->audio_st->codec,
(int16_t *)audio_buf, &data_size,
is->audio_pkt_data, is->audio_pkt_size);
SDL_UnlockMutex(is->audio_decoder_mutex);
@ -1074,9 +1074,9 @@ static int audio_decode_frame(VideoState *is, uint8_t *audio_buf, double *pts_pt
/* if no pts, then compute it */
pts = is->audio_clock;
*pts_ptr = pts;
n = 2 * is->audio_st->codec.channels;
n = 2 * is->audio_st->codec->channels;
is->audio_clock += (double)data_size /
(double)(n * is->audio_st->codec.sample_rate);
(double)(n * is->audio_st->codec->sample_rate);
#if defined(DEBUG_SYNC)
{
static double last_clock;
@ -1164,7 +1164,7 @@ static int stream_component_open(VideoState *is, int stream_index)
if (stream_index < 0 || stream_index >= ic->nb_streams)
return -1;
enc = &ic->streams[stream_index]->codec;
enc = ic->streams[stream_index]->codec;
/* prepare audio output */
if (enc->codec_type == CODEC_TYPE_AUDIO) {
@ -1248,7 +1248,7 @@ static void stream_component_close(VideoState *is, int stream_index)
AVFormatContext *ic = is->ic;
AVCodecContext *enc;
enc = &ic->streams[stream_index]->codec;
enc = ic->streams[stream_index]->codec;
switch(enc->codec_type) {
case CODEC_TYPE_AUDIO:
@ -1387,7 +1387,7 @@ static int decode_thread(void *arg)
}
for(i = 0; i < ic->nb_streams; i++) {
AVCodecContext *enc = &ic->streams[i]->codec;
AVCodecContext *enc = ic->streams[i]->codec;
switch(enc->codec_type) {
case CODEC_TYPE_AUDIO:
if (audio_index < 0 && !audio_disable)
@ -1455,7 +1455,7 @@ static int decode_thread(void *arg)
}
if (is->video_stream >= 0) {
packet_queue_flush(&is->videoq);
avcodec_flush_buffers(&ic->streams[video_index]->codec);
avcodec_flush_buffers(ic->streams[video_index]->codec);
}
}
SDL_UnlockMutex(is->audio_decoder_mutex);
@ -1594,12 +1594,12 @@ void stream_cycle_channel(VideoState *is, int codec_type)
if (stream_index == start_index)
return;
st = ic->streams[stream_index];
if (st->codec.codec_type == codec_type) {
if (st->codec->codec_type == codec_type) {
/* check that parameters are OK */
switch(codec_type) {
case CODEC_TYPE_AUDIO:
if (st->codec.sample_rate != 0 &&
st->codec.channels != 0)
if (st->codec->sample_rate != 0 &&
st->codec->channels != 0)
goto the_end;
break;
case CODEC_TYPE_VIDEO:

106
ffserver.c
View File

@ -728,8 +728,8 @@ static void close_connection(HTTPContext *c)
/* close each frame parser */
for(i=0;i<c->fmt_in->nb_streams;i++) {
st = c->fmt_in->streams[i];
if (st->codec.codec) {
avcodec_close(&st->codec);
if (st->codec->codec) {
avcodec_close(st->codec);
}
}
av_close_input_file(c->fmt_in);
@ -1002,7 +1002,7 @@ static int find_stream_in_feed(FFStream *feed, AVCodecContext *codec, int bit_ra
int best = -1;
for (i = 0; i < feed->nb_streams; i++) {
AVCodecContext *feed_codec = &feed->streams[i]->codec;
AVCodecContext *feed_codec = feed->streams[i]->codec;
if (feed_codec->codec_id != codec->codec_id ||
feed_codec->sample_rate != codec->sample_rate ||
@ -1044,7 +1044,7 @@ static int modify_current_stream(HTTPContext *c, char *rates)
return 0;
for (i = 0; i < req->nb_streams; i++) {
AVCodecContext *codec = &req->streams[i]->codec;
AVCodecContext *codec = req->streams[i]->codec;
switch(rates[i]) {
case 0:
@ -1659,10 +1659,10 @@ static void compute_stats(HTTPContext *c)
for(i=0;i<stream->nb_streams;i++) {
AVStream *st = stream->streams[i];
AVCodec *codec = avcodec_find_encoder(st->codec.codec_id);
switch(st->codec.codec_type) {
AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
switch(st->codec->codec_type) {
case CODEC_TYPE_AUDIO:
audio_bit_rate += st->codec.bit_rate;
audio_bit_rate += st->codec->bit_rate;
if (codec) {
if (*audio_codec_name)
audio_codec_name_extra = "...";
@ -1670,7 +1670,7 @@ static void compute_stats(HTTPContext *c)
}
break;
case CODEC_TYPE_VIDEO:
video_bit_rate += st->codec.bit_rate;
video_bit_rate += st->codec->bit_rate;
if (codec) {
if (*video_codec_name)
video_codec_name_extra = "...";
@ -1678,7 +1678,7 @@ static void compute_stats(HTTPContext *c)
}
break;
case CODEC_TYPE_DATA:
video_bit_rate += st->codec.bit_rate;
video_bit_rate += st->codec->bit_rate;
break;
default:
av_abort();
@ -1744,26 +1744,26 @@ static void compute_stats(HTTPContext *c)
for (i = 0; i < stream->nb_streams; i++) {
AVStream *st = stream->streams[i];
AVCodec *codec = avcodec_find_encoder(st->codec.codec_id);
AVCodec *codec = avcodec_find_encoder(st->codec->codec_id);
const char *type = "unknown";
char parameters[64];
parameters[0] = 0;
switch(st->codec.codec_type) {
switch(st->codec->codec_type) {
case CODEC_TYPE_AUDIO:
type = "audio";
break;
case CODEC_TYPE_VIDEO:
type = "video";
snprintf(parameters, sizeof(parameters), "%dx%d, q=%d-%d, fps=%d", st->codec.width, st->codec.height,
st->codec.qmin, st->codec.qmax, st->codec.time_base.den / st->codec.time_base.num);
snprintf(parameters, sizeof(parameters), "%dx%d, q=%d-%d, fps=%d", st->codec->width, st->codec->height,
st->codec->qmin, st->codec->qmax, st->codec->time_base.den / st->codec->time_base.num);
break;
default:
av_abort();
}
url_fprintf(pb, "<tr><td align=right>%d<td>%s<td align=right>%d<td>%s<td>%s\n",
i, type, st->codec.bit_rate/1000, codec ? codec->name : "", parameters);
i, type, st->codec->bit_rate/1000, codec ? codec->name : "", parameters);
}
url_fprintf(pb, "</table>\n");
@ -1786,7 +1786,7 @@ static void compute_stats(HTTPContext *c)
for(i=0;i<stream->nb_streams;i++) {
AVStream *st = stream->streams[i];
FeedData *fdata = st->priv_data;
enc = &st->codec;
enc = st->codec;
avcodec_string(buf, sizeof(buf), enc);
avg = fdata->avg_frame_size * (float)enc->rate * 8.0;
@ -1822,10 +1822,10 @@ static void compute_stats(HTTPContext *c)
if (c1->stream) {
for (j = 0; j < c1->stream->nb_streams; j++) {
if (!c1->stream->feed) {
bitrate += c1->stream->streams[j]->codec.bit_rate;
bitrate += c1->stream->streams[j]->codec->bit_rate;
} else {
if (c1->feed_streams[j] >= 0) {
bitrate += c1->stream->feed->streams[c1->feed_streams[j]]->codec.bit_rate;
bitrate += c1->stream->feed->streams[c1->feed_streams[j]]->codec->bit_rate;
}
}
}
@ -1867,12 +1867,12 @@ static void open_parser(AVFormatContext *s, int i)
AVStream *st = s->streams[i];
AVCodec *codec;
if (!st->codec.codec) {
codec = avcodec_find_decoder(st->codec.codec_id);
if (!st->codec->codec) {
codec = avcodec_find_decoder(st->codec->codec_id);
if (codec && (codec->capabilities & CODEC_CAP_PARSE_ONLY)) {
st->codec.parse_only = 1;
if (avcodec_open(&st->codec, codec) < 0) {
st->codec.parse_only = 0;
st->codec->parse_only = 1;
if (avcodec_open(st->codec, codec) < 0) {
st->codec->parse_only = 0;
}
}
}
@ -1935,7 +1935,7 @@ static int open_input_stream(HTTPContext *c, const char *info)
c->pts_stream_index = 0;
for(i=0;i<c->stream->nb_streams;i++) {
if (c->pts_stream_index == 0 &&
c->stream->streams[i]->codec.codec_type == CODEC_TYPE_VIDEO) {
c->stream->streams[i]->codec->codec_type == CODEC_TYPE_VIDEO) {
c->pts_stream_index = i;
}
}
@ -2010,12 +2010,12 @@ static int http_prepare_data(HTTPContext *c)
*st = *src;
st->priv_data = 0;
st->codec.frame_number = 0; /* XXX: should be done in
st->codec->frame_number = 0; /* XXX: should be done in
AVStream, not in codec */
/* I'm pretty sure that this is not correct...
* However, without it, we crash
*/
st->codec.coded_frame = &dummy_frame;
st->codec->coded_frame = &dummy_frame;
}
c->got_key_frame = 0;
@ -2144,13 +2144,13 @@ static int http_prepare_data(HTTPContext *c)
av_free_packet(&pkt);
break;
}
codec = &ctx->streams[0]->codec;
codec = ctx->streams[0]->codec;
/* only one stream per RTP connection */
pkt.stream_index = 0;
} else {
ctx = &c->fmt_ctx;
/* Fudge here */
codec = &ctx->streams[pkt.stream_index]->codec;
codec = ctx->streams[pkt.stream_index]->codec;
}
codec->coded_frame->key_frame = ((pkt.flags & PKT_FLAG_KEY) != 0);
@ -2462,8 +2462,8 @@ static int http_receive_data(HTTPContext *c)
goto fail;
}
for (i = 0; i < s.nb_streams; i++) {
memcpy(&feed->streams[i]->codec,
&s.streams[i]->codec, sizeof(AVCodecContext));
memcpy(feed->streams[i]->codec,
s.streams[i]->codec, sizeof(AVCodecContext));
}
av_freep(&s.priv_data);
}
@ -2638,10 +2638,10 @@ static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
private_payload_type = RTP_PT_PRIVATE;
for(i = 0; i < stream->nb_streams; i++) {
st = stream->streams[i];
if (st->codec.codec_id == CODEC_ID_MPEG2TS) {
if (st->codec->codec_id == CODEC_ID_MPEG2TS) {
mediatype = "video";
} else {
switch(st->codec.codec_type) {
switch(st->codec->codec_type) {
case CODEC_TYPE_AUDIO:
mediatype = "audio";
break;
@ -2655,7 +2655,7 @@ static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
}
/* NOTE: the port indication is not correct in case of
unicast. It is not an issue because RTSP gives it */
payload_type = rtp_get_payload_type(&st->codec);
payload_type = rtp_get_payload_type(st->codec);
if (payload_type < 0)
payload_type = private_payload_type++;
if (stream->is_multicast) {
@ -2667,17 +2667,17 @@ static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer,
mediatype, port, payload_type);
if (payload_type >= RTP_PT_PRIVATE) {
/* for private payload type, we need to give more info */
switch(st->codec.codec_id) {
switch(st->codec->codec_id) {
case CODEC_ID_MPEG4:
{
uint8_t *data;
url_fprintf(pb, "a=rtpmap:%d MP4V-ES/%d\n",
payload_type, 90000);
/* we must also add the mpeg4 header */
data = st->codec.extradata;
data = st->codec->extradata;
if (data) {
url_fprintf(pb, "a=fmtp:%d config=", payload_type);
for(j=0;j<st->codec.extradata_size;j++) {
for(j=0;j<st->codec->extradata_size;j++) {
url_fprintf(pb, "%02x", data[j]);
}
url_fprintf(pb, "\n");
@ -3222,8 +3222,8 @@ static AVStream *add_av_stream1(FFStream *stream, AVCodecContext *codec)
if (!fst)
return NULL;
fst->priv_data = av_mallocz(sizeof(FeedData));
memcpy(&fst->codec, codec, sizeof(AVCodecContext));
fst->codec.coded_frame = &dummy_frame;
memcpy(fst->codec, codec, sizeof(AVCodecContext));
fst->codec->coded_frame = &dummy_frame;
fst->index = stream->nb_streams;
av_set_pts_info(fst, 33, 1, 90000);
stream->streams[stream->nb_streams++] = fst;
@ -3237,10 +3237,10 @@ static int add_av_stream(FFStream *feed, AVStream *st)
AVCodecContext *av, *av1;
int i;
av = &st->codec;
av = st->codec;
for(i=0;i<feed->nb_streams;i++) {
st = feed->streams[i];
av1 = &st->codec;
av1 = st->codec;
if (av1->codec_id == av->codec_id &&
av1->codec_type == av->codec_type &&
av1->bit_rate == av->bit_rate) {
@ -3297,8 +3297,8 @@ static void extract_mpeg4_header(AVFormatContext *infile)
mpeg4_count = 0;
for(i=0;i<infile->nb_streams;i++) {
st = infile->streams[i];
if (st->codec.codec_id == CODEC_ID_MPEG4 &&
st->codec.extradata_size == 0) {
if (st->codec->codec_id == CODEC_ID_MPEG4 &&
st->codec->extradata_size == 0) {
mpeg4_count++;
}
}
@ -3310,9 +3310,9 @@ static void extract_mpeg4_header(AVFormatContext *infile)
if (av_read_packet(infile, &pkt) < 0)
break;
st = infile->streams[pkt.stream_index];
if (st->codec.codec_id == CODEC_ID_MPEG4 &&
st->codec.extradata_size == 0) {
av_freep(&st->codec.extradata);
if (st->codec->codec_id == CODEC_ID_MPEG4 &&
st->codec->extradata_size == 0) {
av_freep(&st->codec->extradata);
/* fill extradata with the header */
/* XXX: we make hard suppositions here ! */
p = pkt.data;
@ -3322,9 +3322,9 @@ static void extract_mpeg4_header(AVFormatContext *infile)
p[2] == 0x01 && p[3] == 0xb6) {
size = p - pkt.data;
// av_hex_dump(pkt.data, size);
st->codec.extradata = av_malloc(size);
st->codec.extradata_size = size;
memcpy(st->codec.extradata, pkt.data, size);
st->codec->extradata = av_malloc(size);
st->codec->extradata_size = size;
memcpy(st->codec->extradata, pkt.data, size);
break;
}
p++;
@ -3376,7 +3376,7 @@ static void build_file_streams(void)
extract_mpeg4_header(infile);
for(i=0;i<infile->nb_streams;i++) {
add_av_stream1(stream, &infile->streams[i]->codec);
add_av_stream1(stream, infile->streams[i]->codec);
}
av_close_input_file(infile);
}
@ -3441,8 +3441,8 @@ static void build_feed_streams(void)
} else {
AVCodecContext *ccf, *ccs;
ccf = &sf->codec;
ccs = &ss->codec;
ccf = sf->codec;
ccs = ss->codec;
#define CHECK_CODEC(x) (ccf->x != ccs->x)
if (CHECK_CODEC(codec) || CHECK_CODEC(codec_type)) {
@ -3550,10 +3550,10 @@ static void compute_bandwidth(void)
bandwidth = 0;
for(i=0;i<stream->nb_streams;i++) {
AVStream *st = stream->streams[i];
switch(st->codec.codec_type) {
switch(st->codec->codec_type) {
case CODEC_TYPE_AUDIO:
case CODEC_TYPE_VIDEO:
bandwidth += st->codec.bit_rate;
bandwidth += st->codec->bit_rate;
break;
default:
break;
@ -3665,7 +3665,7 @@ static void add_codec(FFStream *stream, AVCodecContext *av)
if (!st)
return;
stream->streams[stream->nb_streams++] = st;
memcpy(&st->codec, av, sizeof(AVCodecContext));
memcpy(st->codec, av, sizeof(AVCodecContext));
}
static int opt_audio_codec(const char *arg)

34
libavformat/4xm.c
View File

@ -166,11 +166,11 @@ static int fourxm_read_header(AVFormatContext *s,
fourxm->video_stream_index = st->index;
st->codec.codec_type = CODEC_TYPE_VIDEO;
st->codec.codec_id = CODEC_ID_4XM;
st->codec.codec_tag = 0; /* no fourcc */
st->codec.width = fourxm->width;
st->codec.height = fourxm->height;
st->codec->codec_type = CODEC_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_4XM;
st->codec->codec_tag = 0; /* no fourcc */
st->codec->width = fourxm->width;
st->codec->height = fourxm->height;
} else if (fourcc_tag == strk_TAG) {
/* check that there is enough data */
@ -205,20 +205,20 @@ static int fourxm_read_header(AVFormatContext *s,
fourxm->tracks[current_track].stream_index = st->index;
st->codec.codec_type = CODEC_TYPE_AUDIO;
st->codec.codec_tag = 1;
st->codec.channels = fourxm->tracks[current_track].channels;
st->codec.sample_rate = fourxm->tracks[current_track].sample_rate;
st->codec.bits_per_sample = fourxm->tracks[current_track].bits;
st->codec.bit_rate = st->codec.channels * st->codec.sample_rate *
st->codec.bits_per_sample;
st->codec.block_align = st->codec.channels * st->codec.bits_per_sample;
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->codec_tag = 1;
st->codec->channels = fourxm->tracks[current_track].channels;
st->codec->sample_rate = fourxm->tracks[current_track].sample_rate;
st->codec->bits_per_sample = fourxm->tracks[current_track].bits;
st->codec->bit_rate = st->codec->channels * st->codec->sample_rate *
st->codec->bits_per_sample;
st->codec->block_align = st->codec->channels * st->codec->bits_per_sample;
if (fourxm->tracks[current_track].adpcm)
st->codec.codec_id = CODEC_ID_ADPCM_4XM;
else if (st->codec.bits_per_sample == 8)
st->codec.codec_id = CODEC_ID_PCM_U8;
st->codec->codec_id = CODEC_ID_ADPCM_4XM;
else if (st->codec->bits_per_sample == 8)
st->codec->codec_id = CODEC_ID_PCM_U8;
else
st->codec.codec_id = CODEC_ID_PCM_S16LE;
st->codec->codec_id = CODEC_ID_PCM_S16LE;
}
}

24
libavformat/amr.c
View File

@ -31,7 +31,7 @@ static const unsigned char AMRWB_header [] = "#!AMR-WB\n";
static int amr_write_header(AVFormatContext *s)
{
ByteIOContext *pb = &s->pb;
AVCodecContext *enc = &s->streams[0]->codec;
AVCodecContext *enc = s->streams[0]->codec;
s->priv_data = NULL;
@ -100,11 +100,11 @@ static int amr_read_header(AVFormatContext *s,
return AVERROR_NOMEM;
}
st->codec.codec_type = CODEC_TYPE_AUDIO;
st->codec.codec_tag = MKTAG('s', 'a', 'w', 'b');
st->codec.codec_id = CODEC_ID_AMR_WB;
st->codec.channels = 1;
st->codec.sample_rate = 16000;
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->codec_tag = MKTAG('s', 'a', 'w', 'b');
st->codec->codec_id = CODEC_ID_AMR_WB;
st->codec->channels = 1;
st->codec->sample_rate = 16000;
}
else
{
@ -114,11 +114,11 @@ static int amr_read_header(AVFormatContext *s,
return AVERROR_NOMEM;
}
st->codec.codec_type = CODEC_TYPE_AUDIO;
st->codec.codec_tag = MKTAG('s', 'a', 'm', 'r');
st->codec.codec_id = CODEC_ID_AMR_NB;
st->codec.channels = 1;
st->codec.sample_rate = 8000;
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->codec_tag = MKTAG('s', 'a', 'm', 'r');
st->codec->codec_id = CODEC_ID_AMR_NB;
st->codec->channels = 1;
st->codec->sample_rate = 8000;
}
return 0;
@ -129,7 +129,7 @@ static int amr_read_header(AVFormatContext *s,
static int amr_read_packet(AVFormatContext *s,
AVPacket *pkt)
{
AVCodecContext *enc = &s->streams[0]->codec;
AVCodecContext *enc = s->streams[0]->codec;
if (enc->codec_id == CODEC_ID_AMR_NB)
{

8
libavformat/asf-enc.c
View File

@ -289,7 +289,7 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
bit_rate = 0;
for(n=0;n<s->nb_streams;n++) {
enc = &s->streams[n]->codec;
enc = s->streams[n]->codec;
av_set_pts_info(s->streams[n], 32, 1, 1000); /* 32 bit pts in ms */
@ -353,7 +353,7 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
int er_spr_len = 0;
// ASFStream *stream = &asf->streams[n];
enc = &s->streams[n]->codec;
enc = s->streams[n]->codec;
asf->streams[n].num = n + 1;
asf->streams[n].seq = 0;
@ -437,7 +437,7 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
for(n=0;n<s->nb_streams;n++) {
AVCodec *p;
enc = &s->streams[n]->codec;
enc = s->streams[n]->codec;
p = avcodec_find_encoder(enc->codec_id);
put_le16(pb, asf->streams[n].num);
@ -730,7 +730,7 @@ static int asf_write_packet(AVFormatContext *s, AVPacket *pkt)
int64_t packet_st,pts;
int start_sec,i;
codec = &s->streams[pkt->stream_index]->codec;
codec = s->streams[pkt->stream_index]->codec;
stream = &asf->streams[pkt->stream_index];
//XXX /FIXME use duration from AVPacket (quick hack by)

52
libavformat/asf.c
View File

@ -216,9 +216,9 @@ static int asf_read_header(AVFormatContext *s, AVFormatParameters *ap)
asf->asfid2avid[st->id] = s->nb_streams - 1;
get_le32(pb);
st->codec.codec_type = type;
st->codec->codec_type = type;
if (type == CODEC_TYPE_AUDIO) {
get_wav_header(pb, &st->codec, type_specific_size);
get_wav_header(pb, st->codec, type_specific_size);
st->need_parsing = 1;
/* We have to init the frame size at some point .... */
pos2 = url_ftell(pb);
@ -237,9 +237,9 @@ static int asf_read_header(AVFormatContext *s, AVFormatParameters *ap)
|| (asf_st->ds_packet_size/asf_st->ds_chunk_size <= 1))
asf_st->ds_span = 0; // disable descrambling
}
switch (st->codec.codec_id) {
switch (st->codec->codec_id) {
case CODEC_ID_MP3:
st->codec.frame_size = MPA_FRAME_SIZE;
st->codec->frame_size = MPA_FRAME_SIZE;
break;
case CODEC_ID_PCM_S16LE:
case CODEC_ID_PCM_S16BE:
@ -249,11 +249,11 @@ static int asf_read_header(AVFormatContext *s, AVFormatParameters *ap)
case CODEC_ID_PCM_U8:
case CODEC_ID_PCM_ALAW:
case CODEC_ID_PCM_MULAW:
st->codec.frame_size = 1;
st->codec->frame_size = 1;
break;
default:
/* This is probably wrong, but it prevents a crash later */
st->codec.frame_size = 1;
st->codec->frame_size = 1;
break;
}
} else {
@ -262,38 +262,38 @@ static int asf_read_header(AVFormatContext *s, AVFormatParameters *ap)
get_byte(pb);
size = get_le16(pb); /* size */
sizeX= get_le32(pb); /* size */
st->codec.width = get_le32(pb);
st->codec.height = get_le32(pb);
st->codec->width = get_le32(pb);
st->codec->height = get_le32(pb);
/* not available for asf */
get_le16(pb); /* panes */
st->codec.bits_per_sample = get_le16(pb); /* depth */
st->codec->bits_per_sample = get_le16(pb); /* depth */
tag1 = get_le32(pb);
url_fskip(pb, 20);
// av_log(NULL, AV_LOG_DEBUG, "size:%d tsize:%d sizeX:%d\n", size, total_size, sizeX);
size= sizeX;
if (size > 40) {
st->codec.extradata_size = size - 40;
st->codec.extradata = av_mallocz(st->codec.extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
get_buffer(pb, st->codec.extradata, st->codec.extradata_size);
st->codec->extradata_size = size - 40;
st->codec->extradata = av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
get_buffer(pb, st->codec->extradata, st->codec->extradata_size);
}
/* Extract palette from extradata if bpp <= 8 */
/* This code assumes that extradata contains only palette */
/* This is true for all paletted codecs implemented in ffmpeg */
if (st->codec.extradata_size && (st->codec.bits_per_sample <= 8)) {
st->codec.palctrl = av_mallocz(sizeof(AVPaletteControl));
if (st->codec->extradata_size && (st->codec->bits_per_sample <= 8)) {
st->codec->palctrl = av_mallocz(sizeof(AVPaletteControl));
#ifdef WORDS_BIGENDIAN
for (i = 0; i < FFMIN(st->codec.extradata_size, AVPALETTE_SIZE)/4; i++)
st->codec.palctrl->palette[i] = bswap_32(((uint32_t*)st->codec.extradata)[i]);
for (i = 0; i < FFMIN(st->codec->extradata_size, AVPALETTE_SIZE)/4; i++)
st->codec->palctrl->palette[i] = bswap_32(((uint32_t*)st->codec->extradata)[i]);
#else
memcpy(st->codec.palctrl->palette, st->codec.extradata,
FFMIN(st->codec.extradata_size, AVPALETTE_SIZE));
memcpy(st->codec->palctrl->palette, st->codec->extradata,
FFMIN(st->codec->extradata_size, AVPALETTE_SIZE));
#endif
st->codec.palctrl->palette_changed = 1;
st->codec->palctrl->palette_changed = 1;
}
st->codec.codec_tag = tag1;
st->codec.codec_id = codec_get_id(codec_bmp_tags, tag1);
st->codec->codec_tag = tag1;
st->codec->codec_id = codec_get_id(codec_bmp_tags, tag1);
if(tag1 == MKTAG('D', 'V', 'R', ' '))
st->need_parsing = 1;
}
@ -398,7 +398,7 @@ static int asf_read_header(AVFormatContext *s, AVFormatParameters *ap)
AVStream *st = s->streams[i];
if (st) {
av_free(st->priv_data);
av_free(st->codec.extradata);
av_free(st->codec->extradata);
}
av_free(st);
}
@ -608,8 +608,8 @@ static int asf_read_packet(AVFormatContext *s, AVPacket *pkt)
asf_st->packet_pos= asf->packet_pos;
//printf("new packet: stream:%d key:%d packet_key:%d audio:%d size:%d\n",
//asf->stream_index, asf->packet_key_frame, asf_st->pkt.flags & PKT_FLAG_KEY,
//s->streams[asf->stream_index]->codec.codec_type == CODEC_TYPE_AUDIO, asf->packet_obj_size);
if (s->streams[asf->stream_index]->codec.codec_type == CODEC_TYPE_AUDIO)
//s->streams[asf->stream_index]->codec->codec_type == CODEC_TYPE_AUDIO, asf->packet_obj_size);
if (s->streams[asf->stream_index]->codec->codec_type == CODEC_TYPE_AUDIO)
asf->packet_key_frame = 1;
if (asf->packet_key_frame)
asf_st->pkt.flags |= PKT_FLAG_KEY;
@ -666,8 +666,8 @@ static int asf_read_close(AVFormatContext *s)
for(i=0;i<s->nb_streams;i++) {
AVStream *st = s->streams[i];
av_free(st->priv_data);
av_free(st->codec.extradata);
av_free(st->codec.palctrl);
av_free(st->codec->extradata);
av_free(st->codec->palctrl);
}
return 0;
}

12
libavformat/au.c
View File

@ -63,7 +63,7 @@ static int au_write_header(AVFormatContext *s)
s->priv_data = NULL;
/* format header */
if (put_au_header(pb, &s->streams[0]->codec) < 0) {
if (put_au_header(pb, s->streams[0]->codec) < 0) {
return -1;
}
@ -143,11 +143,11 @@ static int au_read_header(AVFormatContext *s,
st = av_new_stream(s, 0);
if (!st)
return -1;
st->codec.codec_type = CODEC_TYPE_AUDIO;
st->codec.codec_tag = id;
st->codec.codec_id = codec;
st->codec.channels = channels;
st->codec.sample_rate = rate;
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->codec_tag = id;
st->codec->codec_id = codec;
st->codec->channels = channels;
st->codec->sample_rate = rate;
av_set_pts_info(st, 64, 1, rate);
return 0;
}

12
libavformat/audio.c
View File

@ -162,8 +162,8 @@ static int audio_write_header(AVFormatContext *s1)
int ret;
st = s1->streams[0];
s->sample_rate = st->codec.sample_rate;
s->channels = st->codec.channels;
s->sample_rate = st->codec->sample_rate;
s->channels = st->codec->channels;
ret = audio_open(s, 1, NULL);
if (ret < 0) {
return AVERROR_IO;
@ -234,10 +234,10 @@ static int audio_read_header(AVFormatContext *s1, AVFormatParameters *ap)
}
/* take real parameters */
st->codec.codec_type = CODEC_TYPE_AUDIO;
st->codec.codec_id = s->codec_id;
st->codec.sample_rate = s->sample_rate;
st->codec.channels = s->channels;
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->codec_id = s->codec_id;
st->codec->sample_rate = s->sample_rate;
st->codec->channels = s->channels;
av_set_pts_info(st, 48, 1, 1000000); /* 48 bits pts in us */
return 0;

4
libavformat/avformat.h
View File

@ -5,7 +5,7 @@
extern "C" {
#endif
#define LIBAVFORMAT_BUILD 4628
#define LIBAVFORMAT_BUILD 4629
#define LIBAVFORMAT_VERSION_INT FFMPEG_VERSION_INT
#define LIBAVFORMAT_VERSION FFMPEG_VERSION
@ -216,7 +216,7 @@ typedef struct AVIndexEntry {
typedef struct AVStream {
int index; /* stream index in AVFormatContext */
int id; /* format specific stream id */
AVCodecContext codec; /* codec context */
AVCodecContext *codec; /* codec context */
/**
* real base frame rate of the stream.
* for example if the timebase is 1/90000 and all frames have either

62
libavformat/avidec.c
View File

@ -178,7 +178,7 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap)
goto fail;
ast = s->streams[0]->priv_data;
av_freep(&s->streams[0]->codec.extradata);
av_freep(&s->streams[0]->codec->extradata);
av_freep(&s->streams[0]);
s->nb_streams = 0;
avi->dv_demux = dv_init_demux(s);
@ -199,7 +199,7 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap)
}
st = s->streams[stream_index];
ast = st->priv_data;
st->codec.stream_codec_tag= handler;
st->codec->stream_codec_tag= handler;
get_le32(pb); /* flags */
get_le16(pb); /* priority */
@ -259,10 +259,10 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap)
switch(codec_type) {
case CODEC_TYPE_VIDEO:
get_le32(pb); /* size */
st->codec.width = get_le32(pb);
st->codec.height = get_le32(pb);
st->codec->width = get_le32(pb);
st->codec->height = get_le32(pb);
get_le16(pb); /* panes */
st->codec.bits_per_sample= get_le16(pb); /* depth */
st->codec->bits_per_sample= get_le16(pb); /* depth */
tag1 = get_le32(pb);
get_le32(pb); /* ImageSize */
get_le32(pb); /* XPelsPerMeter */
@ -271,41 +271,41 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap)
get_le32(pb); /* ClrImportant */
if(size > 10*4 && size<(1<<30)){
st->codec.extradata_size= size - 10*4;
st->codec.extradata= av_malloc(st->codec.extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
get_buffer(pb, st->codec.extradata, st->codec.extradata_size);
st->codec->extradata_size= size - 10*4;
st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
get_buffer(pb, st->codec->extradata, st->codec->extradata_size);
}
if(st->codec.extradata_size & 1) //FIXME check if the encoder really did this correctly
if(st->codec->extradata_size & 1) //FIXME check if the encoder really did this correctly
get_byte(pb);
/* Extract palette from extradata if bpp <= 8 */
/* This code assumes that extradata contains only palette */
/* This is true for all paletted codecs implemented in ffmpeg */
if (st->codec.extradata_size && (st->codec.bits_per_sample <= 8)) {
st->codec.palctrl = av_mallocz(sizeof(AVPaletteControl));
if (st->codec->extradata_size && (st->codec->bits_per_sample <= 8)) {
st->codec->palctrl = av_mallocz(sizeof(AVPaletteControl));
#ifdef WORDS_BIGENDIAN
for (i = 0; i < FFMIN(st->codec.extradata_size, AVPALETTE_SIZE)/4; i++)
st->codec.palctrl->palette[i] = bswap_32(((uint32_t*)st->codec.extradata)[i]);
for (i = 0; i < FFMIN(st->codec->extradata_size, AVPALETTE_SIZE)/4; i++)
st->codec->palctrl->palette[i] = bswap_32(((uint32_t*)st->codec->extradata)[i]);
#else
memcpy(st->codec.palctrl->palette, st->codec.extradata,
FFMIN(st->codec.extradata_size, AVPALETTE_SIZE));
memcpy(st->codec->palctrl->palette, st->codec->extradata,
FFMIN(st->codec->extradata_size, AVPALETTE_SIZE));
#endif
st->codec.palctrl->palette_changed = 1;
st->codec->palctrl->palette_changed = 1;
}
#ifdef DEBUG
print_tag("video", tag1, 0);
#endif
st->codec.codec_type = CODEC_TYPE_VIDEO;
st->codec.codec_tag = tag1;
st->codec.codec_id = codec_get_id(codec_bmp_tags, tag1);
if (st->codec.codec_id == CODEC_ID_XAN_WC4)
st->codec->codec_type = CODEC_TYPE_VIDEO;
st->codec->codec_tag = tag1;
st->codec->codec_id = codec_get_id(codec_bmp_tags, tag1);
if (st->codec->codec_id == CODEC_ID_XAN_WC4)
xan_video = 1;
// url_fskip(pb, size - 5 * 4);
break;
case CODEC_TYPE_AUDIO:
get_wav_header(pb, &st->codec, size);
get_wav_header(pb, st->codec, size);
if (size%2) /* 2-aligned (fix for Stargate SG-1 - 3x18 - Shades of Grey.avi) */
url_fskip(pb, 1);
/* special case time: To support Xan DPCM, hardcode
@ -314,12 +314,12 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap)
/* force parsing as several audio frames can be in
one packet */
if (xan_video)
st->codec.codec_id = CODEC_ID_XAN_DPCM;
st->codec->codec_id = CODEC_ID_XAN_DPCM;
break;
default:
st->codec.codec_type = CODEC_TYPE_DATA;
st->codec.codec_id= CODEC_ID_NONE;
st->codec.codec_tag= 0;
st->codec->codec_type = CODEC_TYPE_DATA;
st->codec->codec_id= CODEC_ID_NONE;
st->codec->codec_tag= 0;
url_fskip(pb, size);
break;
}
@ -337,7 +337,7 @@ static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap)
if (stream_index != s->nb_streams - 1) {
fail:
for(i=0;i<s->nb_streams;i++) {
av_freep(&s->streams[i]->codec.extradata);
av_freep(&s->streams[i]->codec->extradata);
av_freep(&s->streams[i]);
}
return -1;
@ -440,7 +440,7 @@ resync:
//av_log(NULL, AV_LOG_DEBUG, "dts:%Ld offset:%d %d/%d smpl_siz:%d base:%d st:%d size:%d\n", pkt->dts, ast->frame_offset, ast->scale, ast->rate, ast->sample_size, AV_TIME_BASE, n, size);
pkt->stream_index = avi->stream_index;
if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
if(st->index_entries){
AVIndexEntry *e;
int index;
@ -580,9 +580,9 @@ resync:
g = get_byte(pb);
b = get_byte(pb);
get_byte(pb);
st->codec.palctrl->palette[k] = b + (g << 8) + (r << 16);
st->codec->palctrl->palette[k] = b + (g << 8) + (r << 16);
}
st->codec.palctrl->palette_changed = 1;
st->codec->palctrl->palette_changed = 1;
goto resync;
}
@ -786,8 +786,8 @@ static int avi_read_close(AVFormatContext *s)
AVStream *st = s->streams[i];
AVIStream *ast = st->priv_data;
av_free(ast);
av_free(st->codec.extradata);
av_free(st->codec.palctrl);
av_free(st->codec->extradata);
av_free(st->codec->palctrl);
}
if (avi->dv_demux)

14
libavformat/avienc.c
View File

@ -338,7 +338,7 @@ static int avi_write_header(AVFormatContext *s)
video_enc = NULL;
for(n=0;n<s->nb_streams;n++) {
stream = &s->streams[n]->codec;
stream = s->streams[n]->codec;
bitrate += stream->bit_rate;
if (stream->codec_type == CODEC_TYPE_VIDEO)
video_enc = stream;
@ -376,7 +376,7 @@ static int avi_write_header(AVFormatContext *s)
list2 = start_tag(pb, "LIST");
put_tag(pb, "strl");
stream = &s->streams[i]->codec;
stream = s->streams[i]->codec;
/* FourCC should really be set by the codec itself */
if (! stream->codec_tag) {
@ -504,7 +504,7 @@ static int avi_write_ix(AVFormatContext *s)
for (i=0;i<s->nb_streams;i++) {
offset_t ix, pos;
avi_stream2fourcc(&tag[0], i, s->streams[i]->codec.codec_type);
avi_stream2fourcc(&tag[0], i, s->streams[i]->codec->codec_type);
ix_tag[3] = '0' + i;
/* Writing AVI OpenDML leaf index chunk */
@ -576,7 +576,7 @@ static int avi_write_idx1(AVFormatContext *s)
}
if (!empty) {
avi_stream2fourcc(&tag[0], stream_id,
s->streams[stream_id]->codec.codec_type);
s->streams[stream_id]->codec->codec_type);
put_tag(pb, &tag[0]);
put_le32(pb, ie->flags);
put_le32(pb, ie->pos);
@ -591,7 +591,7 @@ static int avi_write_idx1(AVFormatContext *s)
nb_frames = 0;
for(n=0;n<s->nb_streams;n++) {
if (avi->frames_hdr_strm[n] != 0) {
stream = &s->streams[n]->codec;
stream = s->streams[n]->codec;
url_fseek(pb, avi->frames_hdr_strm[n], SEEK_SET);
ff_parse_specific_params(stream, &au_byterate, &au_ssize, &au_scale);
if (au_ssize == 0) {
@ -618,7 +618,7 @@ static int avi_write_packet(AVFormatContext *s, AVPacket *pkt)
unsigned char tag[5];
unsigned int flags=0;
const int stream_index= pkt->stream_index;
AVCodecContext *enc= &s->streams[stream_index]->codec;
AVCodecContext *enc= s->streams[stream_index]->codec;
int size= pkt->size;
// av_log(s, AV_LOG_DEBUG, "%lld %d %d\n", pkt->dts, avi->packet_count[stream_index], stream_index);
@ -705,7 +705,7 @@ static int avi_write_trailer(AVFormatContext *s)
url_fskip(pb, 16);
for (n=nb_frames=0;n<s->nb_streams;n++) {
AVCodecContext *stream = &s->streams[n]->codec;
AVCodecContext *stream = s->streams[n]->codec;
if (stream->codec_type == CODEC_TYPE_VIDEO) {
if (nb_frames < stream->frame_number)
nb_frames = stream->frame_number;

48
libavformat/dv.c
View File

@ -560,8 +560,8 @@ static int dv_extract_audio_info(DVDemuxContext* c, uint8_t* frame)
if (!c->ast[i])
break;
av_set_pts_info(c->ast[i], 64, 1, 30000);
c->ast[i]->codec.codec_type = CODEC_TYPE_AUDIO;
c->ast[i]->codec.codec_id = CODEC_ID_PCM_S16LE;
c->ast[i]->codec->codec_type = CODEC_TYPE_AUDIO;
c->ast[i]->codec->codec_id = CODEC_ID_PCM_S16LE;
av_init_packet(&c->audio_pkt[i]);
c->audio_pkt[i].size = 0;
@ -569,9 +569,9 @@ static int dv_extract_audio_info(DVDemuxContext* c, uint8_t* frame)
c->audio_pkt[i].stream_index = c->ast[i]->index;
c->audio_pkt[i].flags |= PKT_FLAG_KEY;
}
c->ast[i]->codec.sample_rate = dv_audio_frequency[freq];
c->ast[i]->codec.channels = 2;
c->ast[i]->codec.bit_rate = 2 * dv_audio_frequency[freq] * 16;
c->ast[i]->codec->sample_rate = dv_audio_frequency[freq];
c->ast[i]->codec->channels = 2;
c->ast[i]->codec->bit_rate = 2 * dv_audio_frequency[freq] * 16;
c->ast[i]->start_time = 0;
}
c->ach = i;
@ -589,7 +589,7 @@ static int dv_extract_video_info(DVDemuxContext *c, uint8_t* frame)
sys = dv_frame_profile(frame);
if (sys) {
avctx = &c->vst->codec;
avctx = c->vst->codec;
av_set_pts_info(c->vst, 64, sys->frame_rate_base, sys->frame_rate);
avctx->time_base= (AVRational){sys->frame_rate_base, sys->frame_rate};
@ -628,10 +628,10 @@ int dv_assemble_frame(DVMuxContext *c, AVStream* st,
c->has_video = 0;
}
if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
/* FIXME: we have to have more sensible approach than this one */
if (c->has_video)
av_log(&st->codec, AV_LOG_ERROR, "Can't process DV frame #%d. Insufficient audio data or severe sync problem.\n", c->frames);
av_log(st->codec, AV_LOG_ERROR, "Can't process DV frame #%d. Insufficient audio data or severe sync problem.\n", c->frames);
dv_inject_video(c, data, *frame);
c->has_video = 1;
@ -642,7 +642,7 @@ int dv_assemble_frame(DVMuxContext *c, AVStream* st,
reqasize = 4 * dv_audio_frame_size(c->sys, c->frames);
fsize = fifo_size(&c->audio_data, c->audio_data.rptr);
if (st->codec.codec_type == CODEC_TYPE_AUDIO || (c->has_video && fsize >= reqasize)) {
if (st->codec->codec_type == CODEC_TYPE_AUDIO || (c->has_video && fsize >= reqasize)) {
if (fsize + data_size >= reqasize && !c->has_audio) {
if (fsize >= reqasize) {
fifo_read(&c->audio_data, &pcm[0], reqasize, &c->audio_data.rptr);
@ -658,7 +658,7 @@ int dv_assemble_frame(DVMuxContext *c, AVStream* st,
/* FIXME: we have to have more sensible approach than this one */
if (fifo_size(&c->audio_data, c->audio_data.rptr) + data_size >= 100*AVCODEC_MAX_AUDIO_FRAME_SIZE)
av_log(&st->codec, AV_LOG_ERROR, "Can't process DV frame #%d. Insufficient video data or severe sync problem.\n", c->frames);
av_log(st->codec, AV_LOG_ERROR, "Can't process DV frame #%d. Insufficient video data or severe sync problem.\n", c->frames);
fifo_write(&c->audio_data, (uint8_t *)data, data_size, &c->audio_data.wptr);
}
@ -682,7 +682,7 @@ DVMuxContext* dv_init_mux(AVFormatContext* s)
/* We have to sort out where audio and where video stream is */
for (i=0; i<s->nb_streams; i++) {
switch (s->streams[i]->codec.codec_type) {
switch (s->streams[i]->codec->codec_type) {
case CODEC_TYPE_VIDEO:
vst = s->streams[i];
break;
@ -695,13 +695,13 @@ DVMuxContext* dv_init_mux(AVFormatContext* s)
}
/* Some checks -- DV format is very picky about its incoming streams */
if (!vst || vst->codec.codec_id != CODEC_ID_DVVIDEO)
if (!vst || vst->codec->codec_id != CODEC_ID_DVVIDEO)
goto bail_out;
if (ast && (ast->codec.codec_id != CODEC_ID_PCM_S16LE ||
ast->codec.sample_rate != 48000 ||
ast->codec.channels != 2))
if (ast && (ast->codec->codec_id != CODEC_ID_PCM_S16LE ||
ast->codec->sample_rate != 48000 ||
ast->codec->channels != 2))
goto bail_out;
c->sys = dv_codec_profile(&vst->codec);
c->sys = dv_codec_profile(vst->codec);
if (!c->sys)
goto bail_out;
@ -711,7 +711,7 @@ DVMuxContext* dv_init_mux(AVFormatContext* s)
c->has_video = 0;
c->start_time = (time_t)s->timestamp;
c->aspect = 0; /* 4:3 is the default */
if ((int)(av_q2d(vst->codec.sample_aspect_ratio) * vst->codec.width / vst->codec.height * 10) == 17) /* 16:9 */
if ((int)(av_q2d(vst->codec->sample_aspect_ratio) * vst->codec->width / vst->codec->height * 10) == 17) /* 16:9 */
c->aspect = 0x07;
if (ast && fifo_init(&c->audio_data, 100*AVCODEC_MAX_AUDIO_FRAME_SIZE) < 0)
@ -751,9 +751,9 @@ DVDemuxContext* dv_init_demux(AVFormatContext *s)
c->frames = 0;
c->abytes = 0;
c->vst->codec.codec_type = CODEC_TYPE_VIDEO;
c->vst->codec.codec_id = CODEC_ID_DVVIDEO;
c->vst->codec.bit_rate = 25000000;
c->vst->codec->codec_type = CODEC_TYPE_VIDEO;
c->vst->codec->codec_id = CODEC_ID_DVVIDEO;
c->vst->codec->bit_rate = 25000000;
c->vst->start_time = 0;
return c;
@ -790,7 +790,7 @@ int dv_produce_packet(DVDemuxContext *c, AVPacket *pkt,
size = dv_extract_audio_info(c, buf);
for (i=0; i<c->ach; i++) {
c->audio_pkt[i].size = size;
c->audio_pkt[i].pts = c->abytes * 30000*8 / c->ast[i]->codec.bit_rate;
c->audio_pkt[i].pts = c->abytes * 30000*8 / c->ast[i]->codec->bit_rate;
}
dv_extract_audio(buf, c->audio_buf[0], c->audio_buf[1]);
c->abytes += size;
@ -813,7 +813,7 @@ static int64_t dv_frame_offset(AVFormatContext *s, DVDemuxContext *c,
int64_t timestamp, int flags)
{
// FIXME: sys may be wrong if last dv_read_packet() failed (buffer is junk)
const DVprofile* sys = dv_codec_profile(&c->vst->codec);
const DVprofile* sys = dv_codec_profile(c->vst->codec);
int64_t offset;
int64_t size = url_fsize(&s->pb);
int64_t max_offset = ((size-1) / sys->frame_size) * sys->frame_size;
@ -886,12 +886,12 @@ static int dv_read_seek(AVFormatContext *s, int stream_index,
RawDVContext *r = s->priv_data;
DVDemuxContext *c = r->dv_demux;
int64_t offset= dv_frame_offset(s, c, timestamp, flags);
const DVprofile* sys = dv_codec_profile(&c->vst->codec);
const DVprofile* sys = dv_codec_profile(c->vst->codec);
c->frames= offset / sys->frame_size;
if (c->ach)
c->abytes= av_rescale(c->frames,
c->ast[0]->codec.bit_rate * (int64_t)sys->frame_rate_base,
c->ast[0]->codec->bit_rate * (int64_t)sys->frame_rate_base,
8*sys->frame_rate);
dv_flush_audio_packets(c);

24
libavformat/electronicarts.c
View File

@ -188,9 +188,9 @@ static int ea_read_header(AVFormatContext *s,
return AVERROR_NOMEM;
av_set_pts_info(st, 33, 1, 90000);
ea->video_stream_index = st->index;
st->codec.codec_type = CODEC_TYPE_VIDEO;
st->codec.codec_id = CODEC_ID_EA_MJPEG;
st->codec.codec_tag = 0; /* no fourcc */
st->codec->codec_type = CODEC_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_EA_MJPEG;
st->codec->codec_tag = 0; /* no fourcc */
#endif
/* initialize the audio decoder stream */
@ -198,15 +198,15 @@ static int ea_read_header(AVFormatContext *s,
if (!st)
return AVERROR_NOMEM;
av_set_pts_info(st, 33, 1, EA_SAMPLE_RATE);
st->codec.codec_type = CODEC_TYPE_AUDIO;
st->codec.codec_id = CODEC_ID_ADPCM_EA;
st->codec.codec_tag = 0; /* no tag */
st->codec.channels = ea->num_channels;
st->codec.sample_rate = EA_SAMPLE_RATE;
st->codec.bits_per_sample = EA_BITS_PER_SAMPLE;
st->codec.bit_rate = st->codec.channels * st->codec.sample_rate *
st->codec.bits_per_sample / 4;
st->codec.block_align = st->codec.channels * st->codec.bits_per_sample;
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->codec_id = CODEC_ID_ADPCM_EA;
st->codec->codec_tag = 0; /* no tag */
st->codec->channels = ea->num_channels;
st->codec->sample_rate = EA_SAMPLE_RATE;
st->codec->bits_per_sample = EA_BITS_PER_SAMPLE;
st->codec->bit_rate = st->codec->channels * st->codec->sample_rate *
st->codec->bits_per_sample / 4;
st->codec->block_align = st->codec->channels * st->codec->bits_per_sample;
ea->audio_stream_index = st->index;
ea->audio_frame_counter = 0;

16
libavformat/ffm.c
View File

@ -141,7 +141,7 @@ static int ffm_write_header(AVFormatContext *s)
bit_rate = 0;
for(i=0;i<s->nb_streams;i++) {
st = s->streams[i];
bit_rate += st->codec.bit_rate;
bit_rate += st->codec->bit_rate;
}
put_be32(pb, bit_rate);
@ -154,7 +154,7 @@ static int ffm_write_header(AVFormatContext *s)
av_set_pts_info(st, 64, 1, 1000000);
st->priv_data = fst;
codec = &st->codec;
codec = st->codec;
/* generic info */
put_be32(pb, codec->codec_id);
put_byte(pb, codec->codec_type);
@ -247,10 +247,10 @@ static int ffm_write_packet(AVFormatContext *s, AVPacket *pkt)
int size= pkt->size;
//XXX/FIXME use duration from pkt
if (st->codec.codec_type == CODEC_TYPE_AUDIO) {
duration = ((float)st->codec.frame_size / st->codec.sample_rate * 1000000.0);
if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
duration = ((float)st->codec->frame_size / st->codec->sample_rate * 1000000.0);
} else {
duration = (1000000.0 * st->codec.time_base.num / (float)st->codec.time_base.den);
duration = (1000000.0 * st->codec->time_base.num / (float)st->codec->time_base.den);
}
pts = fst->pts;
@ -485,10 +485,10 @@ static int ffm_read_header(AVFormatContext *s, AVFormatParameters *ap)
st->priv_data = fst;
codec = &st->codec;
codec = st->codec;
/* generic info */
st->codec.codec_id = get_be32(pb);
st->codec.codec_type = get_byte(pb); /* codec_type */
st->codec->codec_id = get_be32(pb);
st->codec->codec_type = get_byte(pb); /* codec_type */
codec->bit_rate = get_be32(pb);
st->quality = get_be32(pb);
codec->flags = get_be32(pb);

26
libavformat/flic.c
View File

@ -86,19 +86,19 @@ static int flic_read_header(AVFormatContext *s,
if (!st)
return AVERROR_NOMEM;
flic->video_stream_index = st->index;
st->codec.codec_type = CODEC_TYPE_VIDEO;
st->codec.codec_id = CODEC_ID_FLIC;
st->codec.codec_tag = 0; /* no fourcc */
st->codec.width = LE_16(&header[0x08]);
st->codec.height = LE_16(&header[0x0A]);
st->codec->codec_type = CODEC_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_FLIC;
st->codec->codec_tag = 0; /* no fourcc */
st->codec->width = LE_16(&header[0x08]);
st->codec->height = LE_16(&header[0x0A]);
if (!st->codec.width || !st->codec.height)
if (!st->codec->width || !st->codec->height)
return AVERROR_INVALIDDATA;
/* send over the whole 128-byte FLIC header */
st->codec.extradata_size = FLIC_HEADER_SIZE;
st->codec.extradata = av_malloc(FLIC_HEADER_SIZE);
memcpy(st->codec.extradata, header, FLIC_HEADER_SIZE);
st->codec->extradata_size = FLIC_HEADER_SIZE;
st->codec->extradata = av_malloc(FLIC_HEADER_SIZE);
memcpy(st->codec->extradata, header, FLIC_HEADER_SIZE);
av_set_pts_info(st, 33, 1, 90000);
@ -113,10 +113,10 @@ static int flic_read_header(AVFormatContext *s,
url_fseek(pb, 12, SEEK_SET);
/* send over abbreviated FLIC header chunk */
av_free(st->codec.extradata);
st->codec.extradata_size = 12;
st->codec.extradata = av_malloc(12);
memcpy(st->codec.extradata, header, 12);
av_free(st->codec->extradata);
st->codec->extradata_size = 12;
st->codec->extradata = av_malloc(12);
memcpy(st->codec->extradata, header, 12);
} else if (magic_number == FLIC_FILE_MAGIC_1) {
/*

34
libavformat/flvdec.c
View File

@ -102,7 +102,7 @@ static int flv_read_packet(AVFormatContext *s, AVPacket *pkt)
return AVERROR_NOMEM;
av_set_pts_info(st, 24, 1, 1000); /* 24 bit pts in ms */
st->codec.time_base= (AVRational){1,1000};
st->codec->time_base= (AVRational){1,1000};
}
// av_log(NULL, AV_LOG_DEBUG, "%d %X %d \n", is_audio, flags, st->discard);
if( (st->discard >= AVDISCARD_NONKEY && !((flags >> 4)==1 || is_audio))
@ -116,34 +116,34 @@ static int flv_read_packet(AVFormatContext *s, AVPacket *pkt)
}
if(is_audio){
if(st->codec.sample_rate == 0){
st->codec.codec_type = CODEC_TYPE_AUDIO;
st->codec.channels = (flags&1)+1;
if(st->codec->sample_rate == 0){
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->channels = (flags&1)+1;
if((flags >> 4) == 5)
st->codec.sample_rate= 8000;
st->codec->sample_rate= 8000;
else
st->codec.sample_rate = (44100<<((flags>>2)&3))>>3;
st->codec->sample_rate = (44100<<((flags>>2)&3))>>3;
switch(flags >> 4){/* 0: uncompressed 1: ADPCM 2: mp3 5: Nellymoser 8kHz mono 6: Nellymoser*/
case 0: if (flags&2) st->codec.codec_id = CODEC_ID_PCM_S16BE;
else st->codec.codec_id = CODEC_ID_PCM_S8; break;
case 1: st->codec.codec_id = CODEC_ID_ADPCM_SWF; break;
case 2: st->codec.codec_id = CODEC_ID_MP3; break;
case 0: if (flags&2) st->codec->codec_id = CODEC_ID_PCM_S16BE;
else st->codec->codec_id = CODEC_ID_PCM_S8; break;
case 1: st->codec->codec_id = CODEC_ID_ADPCM_SWF; break;
case 2: st->codec->codec_id = CODEC_ID_MP3; break;
// this is not listed at FLV but at SWF, strange...
case 3: if (flags&2) st->codec.codec_id = CODEC_ID_PCM_S16LE;
else st->codec.codec_id = CODEC_ID_PCM_S8; break;
case 3: if (flags&2) st->codec->codec_id = CODEC_ID_PCM_S16LE;
else st->codec->codec_id = CODEC_ID_PCM_S8; break;
default:
av_log(s, AV_LOG_INFO, "Unsupported audio codec (%x)\n", flags >> 4);
st->codec.codec_tag= (flags >> 4);
st->codec->codec_tag= (flags >> 4);
}
st->codec.bits_per_sample = (flags & 2) ? 16 : 8;
st->codec->bits_per_sample = (flags & 2) ? 16 : 8;
}
}else{
st->codec.codec_type = CODEC_TYPE_VIDEO;
st->codec->codec_type = CODEC_TYPE_VIDEO;
switch(flags & 0xF){
case 2: st->codec.codec_id = CODEC_ID_FLV1; break;
case 2: st->codec->codec_id = CODEC_ID_FLV1; break;
default:
av_log(s, AV_LOG_INFO, "Unsupported video codec (%x)\n", flags & 0xf);
st->codec.codec_tag= flags & 0xF;
st->codec->codec_tag= flags & 0xF;
}
}

4
libavformat/flvenc.c
View File

@ -97,7 +97,7 @@ static int flv_write_header(AVFormatContext *s)
put_be32(pb,0);
for(i=0; i<s->nb_streams; i++){
AVCodecContext *enc = &s->streams[i]->codec;
AVCodecContext *enc = s->streams[i]->codec;
av_set_pts_info(s->streams[i], 24, 1, 1000); /* 24 bit pts in ms */
if(enc->codec_tag == 5){
put_byte(pb,8); // message type
@ -134,7 +134,7 @@ static int flv_write_trailer(AVFormatContext *s)
static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)
{
ByteIOContext *pb = &s->pb;
AVCodecContext *enc = &s->streams[pkt->stream_index]->codec;
AVCodecContext *enc = s->streams[pkt->stream_index]->codec;
FLVContext *flv = s->priv_data;
int size= pkt->size;
int flags;

4
libavformat/gif.c
View File

@ -327,7 +327,7 @@ static int gif_write_header(AVFormatContext *s)
video_enc = NULL;
for(i=0;i<s->nb_streams;i++) {
enc = &s->streams[i]->codec;
enc = s->streams[i]->codec;
if (enc->codec_type != CODEC_TYPE_AUDIO)
video_enc = enc;
}
@ -388,7 +388,7 @@ static int gif_write_video(AVFormatContext *s,
static int gif_write_packet(AVFormatContext *s, AVPacket *pkt)
{
AVCodecContext *codec = &s->streams[pkt->stream_index]->codec;
AVCodecContext *codec = s->streams[pkt->stream_index]->codec;
if (codec->codec_type == CODEC_TYPE_AUDIO)
return 0; /* just ignore audio */
else

14
libavformat/gifdec.c
View File

@ -555,14 +555,14 @@ static int gif_read_header(AVFormatContext * s1,
if (!st)
return -1;
st->codec.codec_type = CODEC_TYPE_VIDEO;
st->codec.codec_id = CODEC_ID_RAWVIDEO;
st->codec.time_base.den = 5;
st->codec.time_base.num = 1;
st->codec->codec_type = CODEC_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_RAWVIDEO;
st->codec->time_base.den = 5;
st->codec->time_base.num = 1;
/* XXX: check if screen size is always valid */
st->codec.width = s->screen_width;
st->codec.height = s->screen_height;
st->codec.pix_fmt = PIX_FMT_RGB24;
st->codec->width = s->screen_width;
st->codec->height = s->screen_height;
st->codec->pix_fmt = PIX_FMT_RGB24;
return 0;
}

24
libavformat/grab.c
View File

@ -109,11 +109,11 @@ static int grab_read_header(AVFormatContext *s1, AVFormatParameters *ap)
}
desired_palette = -1;
if (st->codec.pix_fmt == PIX_FMT_YUV420P) {
if (st->codec->pix_fmt == PIX_FMT_YUV420P) {
desired_palette = VIDEO_PALETTE_YUV420P;
} else if (st->codec.pix_fmt == PIX_FMT_YUV422) {
} else if (st->codec->pix_fmt == PIX_FMT_YUV422) {
desired_palette = VIDEO_PALETTE_YUV422;
} else if (st->codec.pix_fmt == PIX_FMT_BGR24) {
} else if (st->codec->pix_fmt == PIX_FMT_BGR24) {
desired_palette = VIDEO_PALETTE_RGB24;
}
@ -245,15 +245,15 @@ static int grab_read_header(AVFormatContext *s1, AVFormatParameters *ap)
switch(s->frame_format) {
case VIDEO_PALETTE_YUV420P:
frame_size = (width * height * 3) / 2;
st->codec.pix_fmt = PIX_FMT_YUV420P;
st->codec->pix_fmt = PIX_FMT_YUV420P;
break;
case VIDEO_PALETTE_YUV422:
frame_size = width * height * 2;
st->codec.pix_fmt = PIX_FMT_YUV422;
st->codec->pix_fmt = PIX_FMT_YUV422;
break;
case VIDEO_PALETTE_RGB24:
frame_size = width * height * 3;
st->codec.pix_fmt = PIX_FMT_BGR24; /* NOTE: v4l uses BGR24, not RGB24 ! */
st->codec->pix_fmt = PIX_FMT_BGR24; /* NOTE: v4l uses BGR24, not RGB24 ! */
break;
default:
goto fail;
@ -261,12 +261,12 @@ static int grab_read_header(AVFormatContext *s1, AVFormatParameters *ap)
s->fd = video_fd;
s->frame_size = frame_size;
st->codec.codec_type = CODEC_TYPE_VIDEO;
st->codec.codec_id = CODEC_ID_RAWVIDEO;
st->codec.width = width;
st->codec.height = height;
st->codec.time_base.den = frame_rate;
st->codec.time_base.num = frame_rate_base;
st->codec->codec_type = CODEC_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_RAWVIDEO;
st->codec->width = width;
st->codec->height = height;
st->codec->time_base.den = frame_rate;
st->codec->time_base.num = frame_rate_base;
return 0;
fail:

36
libavformat/idcin.c
View File

@ -156,20 +156,20 @@ static int idcin_read_header(AVFormatContext *s,
return AVERROR_NOMEM;
av_set_pts_info(st, 33, 1, 90000);
idcin->video_stream_index = st->index;
st->codec.codec_type = CODEC_TYPE_VIDEO;
st->codec.codec_id = CODEC_ID_IDCIN;
st->codec.codec_tag = 0; /* no fourcc */
st->codec.width = width;
st->codec.height = height;
st->codec->codec_type = CODEC_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_IDCIN;
st->codec->codec_tag = 0; /* no fourcc */
st->codec->width = width;
st->codec->height = height;
/* load up the Huffman tables into extradata */
st->codec.extradata_size = HUFFMAN_TABLE_SIZE;
st->codec.extradata = av_malloc(HUFFMAN_TABLE_SIZE);
if (get_buffer(pb, st->codec.extradata, HUFFMAN_TABLE_SIZE) !=
st->codec->extradata_size = HUFFMAN_TABLE_SIZE;
st->codec->extradata = av_malloc(HUFFMAN_TABLE_SIZE);
if (get_buffer(pb, st->codec->extradata, HUFFMAN_TABLE_SIZE) !=
HUFFMAN_TABLE_SIZE)
return AVERROR_IO;
/* save a reference in order to transport the palette */
st->codec.palctrl = &idcin->palctrl;
st->codec->palctrl = &idcin->palctrl;
/* if sample rate is 0, assume no audio */
if (sample_rate) {
@ -179,17 +179,17 @@ static int idcin_read_header(AVFormatContext *s,
return AVERROR_NOMEM;
av_set_pts_info(st, 33, 1, 90000);
idcin->audio_stream_index = st->index;
st->codec.codec_type = CODEC_TYPE_AUDIO;
st->codec.codec_tag = 1;
st->codec.channels = channels;
st->codec.sample_rate = sample_rate;
st->codec.bits_per_sample = bytes_per_sample * 8;
st->codec.bit_rate = sample_rate * bytes_per_sample * 8 * channels;
st->codec.block_align = bytes_per_sample * channels;
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->codec_tag = 1;
st->codec->channels = channels;
st->codec->sample_rate = sample_rate;
st->codec->bits_per_sample = bytes_per_sample * 8;
st->codec->bit_rate = sample_rate * bytes_per_sample * 8 * channels;
st->codec->block_align = bytes_per_sample * channels;
if (bytes_per_sample == 1)
st->codec.codec_id = CODEC_ID_PCM_U8;
st->codec->codec_id = CODEC_ID_PCM_U8;
else
st->codec.codec_id = CODEC_ID_PCM_S16LE;
st->codec->codec_id = CODEC_ID_PCM_S16LE;
if (sample_rate % 14 != 0) {
idcin->audio_chunk_size1 = (sample_rate / 14) *

28
libavformat/idroq.c
View File

@ -145,11 +145,11 @@ static int roq_read_header(AVFormatContext *s,
/* set the pts reference (1 pts = 1/90000) */
av_set_pts_info(st, 33, 1, 90000);
roq->video_stream_index = st->index;
st->codec.codec_type = CODEC_TYPE_VIDEO;
st->codec.codec_id = CODEC_ID_ROQ;
st->codec.codec_tag = 0; /* no fourcc */
st->codec.width = roq->width;
st->codec.height = roq->height;
st->codec->codec_type = CODEC_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_ROQ;
st->codec->codec_tag = 0; /* no fourcc */
st->codec->width = roq->width;
st->codec->height = roq->height;
if (roq->audio_channels) {
st = av_new_stream(s, 0);
@ -157,15 +157,15 @@ static int roq_read_header(AVFormatContext *s,
return AVERROR_NOMEM;
av_set_pts_info(st, 33, 1, 90000);
roq->audio_stream_index = st->index;
st->codec.codec_type = CODEC_TYPE_AUDIO;
st->codec.codec_id = CODEC_ID_ROQ_DPCM;
st->codec.codec_tag = 0; /* no tag */
st->codec.channels = roq->audio_channels;
st->codec.sample_rate = RoQ_AUDIO_SAMPLE_RATE;
st->codec.bits_per_sample = 16;
st->codec.bit_rate = st->codec.channels * st->codec.sample_rate *
st->codec.bits_per_sample;
st->codec.block_align = st->codec.channels * st->codec.bits_per_sample;
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->codec_id = CODEC_ID_ROQ_DPCM;
st->codec->codec_tag = 0; /* no tag */
st->codec->channels = roq->audio_channels;
st->codec->sample_rate = RoQ_AUDIO_SAMPLE_RATE;
st->codec->bits_per_sample = 16;
st->codec->bit_rate = st->codec->channels * st->codec->sample_rate *
st->codec->bits_per_sample;
st->codec->block_align = st->codec->channels * st->codec->bits_per_sample;
}
return 0;

24
libavformat/img.c
View File

@ -134,9 +134,9 @@ static int img_read_header(AVFormatContext *s1, AVFormatParameters *ap)
s->is_pipe = 1;
if (!ap || !ap->time_base.num) {
st->codec.time_base= (AVRational){1,25};
st->codec->time_base= (AVRational){1,25};
} else {
st->codec.time_base= ap->time_base;
st->codec->time_base= ap->time_base;
}
if (!s->is_pipe) {
@ -166,11 +166,11 @@ static int img_read_header(AVFormatContext *s1, AVFormatParameters *ap)
url_fseek(f, 0, SEEK_SET);
}
st->codec.codec_type = CODEC_TYPE_VIDEO;
st->codec.codec_id = CODEC_ID_RAWVIDEO;
st->codec.width = s->width;
st->codec.height = s->height;
st->codec.pix_fmt = s->pix_fmt;
st->codec->codec_type = CODEC_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_RAWVIDEO;
st->codec->width = s->width;
st->codec->height = s->height;
st->codec->pix_fmt = s->pix_fmt;
s->img_size = avpicture_get_size(s->pix_fmt, (s->width+15)&(~15), (s->height+15)&(~15));
return 0;
@ -232,7 +232,7 @@ static int img_read_packet(AVFormatContext *s1, AVPacket *pkt)
} else {
/* XXX: computing this pts is not necessary as it is done in
the generic code too */
pkt->pts = av_rescale((int64_t)s->img_count * s1->streams[0]->codec.time_base.num, s1->streams[0]->time_base.den, s1->streams[0]->codec.time_base.den) / s1->streams[0]->time_base.num;
pkt->pts = av_rescale((int64_t)s->img_count * s1->streams[0]->codec->time_base.num, s1->streams[0]->time_base.den, s1->streams[0]->codec->time_base.den) / s1->streams[0]->time_base.num;
s->img_count++;
s->img_number++;
return 0;
@ -276,7 +276,7 @@ static int img_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
return -1;
img->img_fmt = img_fmt;
img->pix_fmt = i;
st->codec.pix_fmt = img->pix_fmt;
st->codec->pix_fmt = img->pix_fmt;
return 0;
}
@ -306,8 +306,8 @@ static int img_write_packet(AVFormatContext *s, AVPacket *pkt)
char filename[1024];
AVImageInfo info;
width = st->codec.width;
height = st->codec.height;
width = st->codec->width;
height = st->codec->height;
picture = (AVPicture *)pkt->data;
@ -323,7 +323,7 @@ static int img_write_packet(AVFormatContext *s, AVPacket *pkt)
}
info.width = width;
info.height = height;
info.pix_fmt = st->codec.pix_fmt;
info.pix_fmt = st->codec->pix_fmt;
info.interleaved = 0; /* FIXME: there should be a way to set it right */
info.pict = *picture;
ret = av_write_image(pb, img->img_fmt, &info);

24
libavformat/img2.c
View File

@ -193,8 +193,8 @@ static int img_read_header(AVFormatContext *s1, AVFormatParameters *ap)
}
if(ap && ap->width && ap->height){
st->codec.width = ap->width;
st->codec.height= ap->height;
st->codec->width = ap->width;
st->codec->height= ap->height;
}
if (!s->is_pipe) {
@ -209,17 +209,17 @@ static int img_read_header(AVFormatContext *s1, AVFormatParameters *ap)
}
if(ap->video_codec_id){
st->codec.codec_type = CODEC_TYPE_VIDEO;
st->codec.codec_id = ap->video_codec_id;
st->codec->codec_type = CODEC_TYPE_VIDEO;
st->codec->codec_id = ap->video_codec_id;
}else if(ap->audio_codec_id){
st->codec.codec_type = CODEC_TYPE_AUDIO;
st->codec.codec_id = ap->audio_codec_id;
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->codec_id = ap->audio_codec_id;
}else{
st->codec.codec_type = CODEC_TYPE_VIDEO;
st->codec.codec_id = av_str2id(img_tags, s->path);
st->codec->codec_type = CODEC_TYPE_VIDEO;
st->codec->codec_id = av_str2id(img_tags, s->path);
}
if(st->codec.codec_type == CODEC_TYPE_VIDEO && ap->pix_fmt != PIX_FMT_NONE)
st->codec.pix_fmt = ap->pix_fmt;
if(st->codec->codec_type == CODEC_TYPE_VIDEO && ap->pix_fmt != PIX_FMT_NONE)
st->codec->pix_fmt = ap->pix_fmt;
return 0;
}
@ -231,7 +231,7 @@ static int img_read_packet(AVFormatContext *s1, AVPacket *pkt)
int i;
int size[3]={0}, ret[3]={0};
ByteIOContext f1[3], *f[3]= {&f1[0], &f1[1], &f1[2]};
AVCodecContext *codec= &s1->streams[0]->codec;
AVCodecContext *codec= s1->streams[0]->codec;
if (!s->is_pipe) {
/* loop over input */
@ -314,7 +314,7 @@ static int img_write_packet(AVFormatContext *s, AVPacket *pkt)
VideoData *img = s->priv_data;
ByteIOContext pb1[3], *pb[3]= {&pb1[0], &pb1[1], &pb1[2]};
char filename[1024];
AVCodecContext *codec= &s->streams[ pkt->stream_index ]->codec;
AVCodecContext *codec= s->streams[ pkt->stream_index ]->codec;
int i;
if (!img->is_pipe) {

34
libavformat/ipmovie.c
View File

@ -554,14 +554,14 @@ static int ipmovie_read_header(AVFormatContext *s,
return AVERROR_NOMEM;
av_set_pts_info(st, 33, 1, 90000);
ipmovie->video_stream_index = st->index;
st->codec.codec_type = CODEC_TYPE_VIDEO;
st->codec.codec_id = CODEC_ID_INTERPLAY_VIDEO;
st->codec.codec_tag = 0; /* no fourcc */
st->codec.width = ipmovie->video_width;
st->codec.height = ipmovie->video_height;
st->codec->codec_type = CODEC_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_INTERPLAY_VIDEO;
st->codec->codec_tag = 0; /* no fourcc */
st->codec->width = ipmovie->video_width;
st->codec->height = ipmovie->video_height;
/* palette considerations */
st->codec.palctrl = &ipmovie->palette_control;
st->codec->palctrl = &ipmovie->palette_control;
if (ipmovie->audio_type) {
st = av_new_stream(s, 0);
@ -569,17 +569,17 @@ static int ipmovie_read_header(AVFormatContext *s,
return AVERROR_NOMEM;
av_set_pts_info(st, 33, 1, 90000);
ipmovie->audio_stream_index = st->index;
st->codec.codec_type = CODEC_TYPE_AUDIO;
st->codec.codec_id = ipmovie->audio_type;
st->codec.codec_tag = 0; /* no tag */
st->codec.channels = ipmovie->audio_channels;
st->codec.sample_rate = ipmovie->audio_sample_rate;
st->codec.bits_per_sample = ipmovie->audio_bits;
st->codec.bit_rate = st->codec.channels * st->codec.sample_rate *
st->codec.bits_per_sample;
if (st->codec.codec_id == CODEC_ID_INTERPLAY_DPCM)
st->codec.bit_rate /= 2;
st->codec.block_align = st->codec.channels * st->codec.bits_per_sample;
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->codec_id = ipmovie->audio_type;
st->codec->codec_tag = 0; /* no tag */
st->codec->channels = ipmovie->audio_channels;
st->codec->sample_rate = ipmovie->audio_sample_rate;
st->codec->bits_per_sample = ipmovie->audio_bits;
st->codec->bit_rate = st->codec->channels * st->codec->sample_rate *
st->codec->bits_per_sample;
if (st->codec->codec_id == CODEC_ID_INTERPLAY_DPCM)
st->codec->bit_rate /= 2;
st->codec->block_align = st->codec->channels * st->codec->bits_per_sample;
}
return 0;

38
libavformat/matroska.c
View File

@ -2273,46 +2273,46 @@ matroska_read_header (AVFormatContext *s,
return AVERROR_NOMEM;
av_set_pts_info(st, 24, 1, 1000); /* 24 bit pts in ms */
st->codec.codec_id = codec_id;
st->codec->codec_id = codec_id;
if(extradata){
st->codec.extradata = extradata;
st->codec.extradata_size = extradata_size;
st->codec->extradata = extradata;
st->codec->extradata_size = extradata_size;
} else if(track->codec_priv && track->codec_priv_size > 0){
st->codec.extradata = av_malloc(track->codec_priv_size);
if(st->codec.extradata == NULL)
st->codec->extradata = av_malloc(track->codec_priv_size);
if(st->codec->extradata == NULL)
return AVERROR_NOMEM;
st->codec.extradata_size = track->codec_priv_size;
memcpy(st->codec.extradata, track->codec_priv,
st->codec->extradata_size = track->codec_priv_size;
memcpy(st->codec->extradata, track->codec_priv,
track->codec_priv_size);
}
if (track->type == MATROSKA_TRACK_TYPE_VIDEO) {
MatroskaVideoTrack *videotrack = (MatroskaVideoTrack *)track;
st->codec.codec_type = CODEC_TYPE_VIDEO;
st->codec.codec_tag = videotrack->fourcc;
st->codec.width = videotrack->pixel_width;
st->codec.height = videotrack->pixel_height;
st->codec->codec_type = CODEC_TYPE_VIDEO;
st->codec->codec_tag = videotrack->fourcc;
st->codec->width = videotrack->pixel_width;
st->codec->height = videotrack->pixel_height;
if (videotrack->display_width == 0)
st->codec.sample_aspect_ratio.num =
st->codec->sample_aspect_ratio.num =
videotrack->pixel_width;
else
st->codec.sample_aspect_ratio.num =
st->codec->sample_aspect_ratio.num =
videotrack->display_width;
if (videotrack->display_height == 0)
st->codec.sample_aspect_ratio.num =
st->codec->sample_aspect_ratio.num =
videotrack->pixel_height;
else
st->codec.sample_aspect_ratio.num =
st->codec->sample_aspect_ratio.num =
videotrack->display_height;
} else if (track->type == MATROSKA_TRACK_TYPE_AUDIO) {
MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *)track;
st->codec.codec_type = CODEC_TYPE_AUDIO;
st->codec.sample_rate = audiotrack->samplerate;
st->codec.channels = audiotrack->channels;
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->sample_rate = audiotrack->samplerate;
st->codec->channels = audiotrack->channels;
}
/* What do we do with private data? E.g. for Vorbis. */
@ -2700,7 +2700,7 @@ matroska_read_close (AVFormatContext *s)
}
for (n = 0; n < s->nb_streams; n++) {
av_free(s->streams[n]->codec.extradata);
av_free(s->streams[n]->codec->extradata);
}
memset(matroska, 0, sizeof(MatroskaDemuxContext));

22
libavformat/mmf.c
View File

@ -61,9 +61,9 @@ static int mmf_write_header(AVFormatContext *s)
offset_t pos;
int rate;
rate = mmf_rate_code(s->streams[0]->codec.sample_rate);
rate = mmf_rate_code(s->streams[0]->codec->sample_rate);
if(rate < 0) {
av_log(s, AV_LOG_ERROR, "Unsupported sample rate %d\n", s->streams[0]->codec.sample_rate);
av_log(s, AV_LOG_ERROR, "Unsupported sample rate %d\n", s->streams[0]->codec->sample_rate);
return -1;
}
@ -96,7 +96,7 @@ static int mmf_write_header(AVFormatContext *s)
mmf->awapos = start_tag(pb, "Awa\x01");
av_set_pts_info(s->streams[0], 64, 1, s->streams[0]->codec.sample_rate);
av_set_pts_info(s->streams[0], 64, 1, s->streams[0]->codec->sample_rate);
put_flush_packet(pb);
@ -144,7 +144,7 @@ static int mmf_write_trailer(AVFormatContext *s)
/* "play wav" */
put_byte(pb, 0); /* start time */
put_byte(pb, 1); /* (channel << 6) | wavenum */
gatetime = size * 500 / s->streams[0]->codec.sample_rate;
gatetime = size * 500 / s->streams[0]->codec->sample_rate;
put_varlength(pb, gatetime); /* duration */
/* "nop" */
@ -239,14 +239,14 @@ static int mmf_read_header(AVFormatContext *s,
if (!st)
return AVERROR_NOMEM;
st->codec.codec_type = CODEC_TYPE_AUDIO;
st->codec.codec_id = CODEC_ID_ADPCM_YAMAHA;
st->codec.sample_rate = rate;
st->codec.channels = 1;
st->codec.bits_per_sample = 4;
st->codec.bit_rate = st->codec.sample_rate * st->codec.bits_per_sample;
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->codec_id = CODEC_ID_ADPCM_YAMAHA;
st->codec->sample_rate = rate;
st->codec->channels = 1;
st->codec->bits_per_sample = 4;
st->codec->bit_rate = st->codec->sample_rate * st->codec->bits_per_sample;
av_set_pts_info(st, 64, 1, st->codec.sample_rate);
av_set_pts_info(st, 64, 1, st->codec->sample_rate);
return 0;
}

162
libavformat/mov.c
View File

@ -481,16 +481,16 @@ static int mov_read_hdlr(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
/* helps parsing the string hereafter... */
c->mp4 = 0;
if(type == MKTAG('v', 'i', 'd', 'e'))
st->codec.codec_type = CODEC_TYPE_VIDEO;
st->codec->codec_type = CODEC_TYPE_VIDEO;
else if(type == MKTAG('s', 'o', 'u', 'n'))
st->codec.codec_type = CODEC_TYPE_AUDIO;
st->codec->codec_type = CODEC_TYPE_AUDIO;
} else if(ctype == 0) { /* MP4 */
/* helps parsing the string hereafter... */
c->mp4 = 1;
if(type == MKTAG('v', 'i', 'd', 'e'))
st->codec.codec_type = CODEC_TYPE_VIDEO;
st->codec->codec_type = CODEC_TYPE_VIDEO;
else if(type == MKTAG('s', 'o', 'u', 'n'))
st->codec.codec_type = CODEC_TYPE_AUDIO;
st->codec->codec_type = CODEC_TYPE_AUDIO;
}
get_be32(pb); /* component manufacture */
get_be32(pb); /* component flags */
@ -591,10 +591,10 @@ static int mov_read_esds(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
#ifdef DEBUG
av_log(NULL, AV_LOG_DEBUG, "Specific MPEG4 header len=%d\n", len);
#endif
st->codec.extradata = (uint8_t*) av_mallocz(len + FF_INPUT_BUFFER_PADDING_SIZE);
if (st->codec.extradata) {
get_buffer(pb, st->codec.extradata, len);
st->codec.extradata_size = len;
st->codec->extradata = (uint8_t*) av_mallocz(len + FF_INPUT_BUFFER_PADDING_SIZE);
if (st->codec->extradata) {
get_buffer(pb, st->codec->extradata, len);
st->codec->extradata_size = len;
}
}
}
@ -703,14 +703,14 @@ static int mov_read_smi(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
// currently SVQ3 decoder expect full STSD header - so let's fake it
// this should be fixed and just SMI header should be passed
av_free(st->codec.extradata);
st->codec.extradata_size = 0x5a + atom.size;
st->codec.extradata = (uint8_t*) av_mallocz(st->codec.extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
av_free(st->codec->extradata);
st->codec->extradata_size = 0x5a + atom.size;
st->codec->extradata = (uint8_t*) av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
if (st->codec.extradata) {
strcpy(st->codec.extradata, "SVQ3"); // fake
get_buffer(pb, st->codec.extradata + 0x5a, atom.size);
//av_log(NULL, AV_LOG_DEBUG, "Reading SMI %Ld %s\n", atom.size, (char*)st->codec.extradata + 0x5a);
if (st->codec->extradata) {
strcpy(st->codec->extradata, "SVQ3"); // fake
get_buffer(pb, st->codec->extradata + 0x5a, atom.size);
//av_log(NULL, AV_LOG_DEBUG, "Reading SMI %Ld %s\n", atom.size, (char*)st->codec->extradata + 0x5a);
} else
url_fskip(pb, atom.size);
@ -724,13 +724,13 @@ static int mov_read_avcC(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
if((uint64_t)atom.size > (1<<30))
return -1;
av_free(st->codec.extradata);
av_free(st->codec->extradata);
st->codec.extradata_size = atom.size;
st->codec.extradata = (uint8_t*) av_mallocz(st->codec.extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
st->codec->extradata_size = atom.size;
st->codec->extradata = (uint8_t*) av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
if (st->codec.extradata) {
get_buffer(pb, st->codec.extradata, atom.size);
if (st->codec->extradata) {
get_buffer(pb, st->codec->extradata, atom.size);
} else
url_fskip(pb, atom.size);
@ -829,7 +829,7 @@ static int mov_read_stsd(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
AVCodec *codec;
codec = avcodec_find_decoder(id);
if (codec)
st->codec.codec_type = codec->type;
st->codec->codec_type = codec->type;
}
#ifdef DEBUG
av_log(NULL, AV_LOG_DEBUG, "size=%d 4CC= %c%c%c%c codec_type=%d\n",
@ -838,23 +838,23 @@ static int mov_read_stsd(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
(format >> 8) & 0xff,
(format >> 16) & 0xff,
(format >> 24) & 0xff,
st->codec.codec_type);
st->codec->codec_type);
#endif
st->codec.codec_tag = format;
if(st->codec.codec_type==CODEC_TYPE_VIDEO) {
st->codec->codec_tag = format;
if(st->codec->codec_type==CODEC_TYPE_VIDEO) {
MOV_atom_t a = { 0, 0, 0 };
st->codec.codec_id = id;
st->codec->codec_id = id;
get_be16(pb); /* version */
get_be16(pb); /* revision level */
get_be32(pb); /* vendor */
get_be32(pb); /* temporal quality */
get_be32(pb); /* spacial quality */
if(st->codec.codec_id == CODEC_ID_MPEG4){ //FIXME this is silly
if(st->codec->codec_id == CODEC_ID_MPEG4){ //FIXME this is silly
get_be16(pb);
get_be16(pb);
}else{
st->codec.width = get_be16(pb); /* width */
st->codec.height = get_be16(pb); /* height */
st->codec->width = get_be16(pb); /* width */
st->codec->height = get_be16(pb); /* height */
}
get_be32(pb); /* horiz resolution */
get_be32(pb); /* vert resolution */
@ -865,16 +865,16 @@ static int mov_read_stsd(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
#endif
get_buffer(pb, codec_name, 32); /* codec name, pascal string (FIXME: true for mp4?) */
if (codec_name[0] <= 31) {
memcpy(st->codec.codec_name, &codec_name[1],codec_name[0]);
st->codec.codec_name[codec_name[0]] = 0;
memcpy(st->codec->codec_name, &codec_name[1],codec_name[0]);
st->codec->codec_name[codec_name[0]] = 0;
}
st->codec.bits_per_sample = get_be16(pb); /* depth */
st->codec.color_table_id = get_be16(pb); /* colortable id */
st->codec->bits_per_sample = get_be16(pb); /* depth */
st->codec->color_table_id = get_be16(pb); /* colortable id */
/* These are set in mov_read_stts and might already be set!
st->codec.time_base.den = 25;
st->codec.time_base.num = 1;
st->codec->time_base.den = 25;
st->codec->time_base.num = 1;
*/
size -= (16+8*4+2+32+2*2);
#if 0
@ -948,8 +948,8 @@ static int mov_read_stsd(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
#else
/* figure out the palette situation */
color_depth = st->codec.bits_per_sample & 0x1F;
color_greyscale = st->codec.bits_per_sample & 0x20;
color_depth = st->codec->bits_per_sample & 0x1F;
color_greyscale = st->codec->bits_per_sample & 0x20;
/* if the depth is 2, 4, or 8 bpp, file is palettized */
if ((color_depth == 2) || (color_depth == 4) ||
@ -970,7 +970,7 @@ static int mov_read_stsd(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
color_index = 0;
}
} else if (st->codec.color_table_id & 0x08) {
} else if (st->codec->color_table_id & 0x08) {
/* if flag bit 3 is set, use the default palette */
color_count = 1 << color_depth;
@ -1012,17 +1012,17 @@ static int mov_read_stsd(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
}
}
st->codec.palctrl = &c->palette_control;
st->codec.palctrl->palette_changed = 1;
st->codec->palctrl = &c->palette_control;
st->codec->palctrl->palette_changed = 1;
} else
st->codec.palctrl = NULL;
st->codec->palctrl = NULL;
a.size = size;
mov_read_default(c, pb, a);
#endif
} else {
st->codec.codec_id = codec_get_id(mov_audio_tags, format);
if(st->codec.codec_id==CODEC_ID_AMR_NB || st->codec.codec_id==CODEC_ID_AMR_WB) //from TS26.244
st->codec->codec_id = codec_get_id(mov_audio_tags, format);
if(st->codec->codec_id==CODEC_ID_AMR_NB || st->codec->codec_id==CODEC_ID_AMR_WB) //from TS26.244
{
#ifdef DEBUG
av_log(NULL, AV_LOG_DEBUG, "AMR-NB or AMR-WB audio identified!!\n");
@ -1045,21 +1045,21 @@ static int mov_read_stsd(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
get_byte(pb); //frames_per_sample
st->duration = AV_NOPTS_VALUE;//Not possible to get from this info, must count number of AMR frames
if(st->codec.codec_id==CODEC_ID_AMR_NB)
if(st->codec->codec_id==CODEC_ID_AMR_NB)
{
st->codec.sample_rate=8000;
st->codec.channels=1;
st->codec->sample_rate=8000;
st->codec->channels=1;
}
else //AMR-WB
{
st->codec.sample_rate=16000;
st->codec.channels=1;
st->codec->sample_rate=16000;
st->codec->channels=1;
}
st->codec.bits_per_sample=16;
st->codec.bit_rate=0; /*It is not possible to tell this before we have
st->codec->bits_per_sample=16;
st->codec->bit_rate=0; /*It is not possible to tell this before we have
an audio frame and even then every frame can be different*/
}
else if( st->codec.codec_tag == MKTAG( 'm', 'p', '4', 's' ))
else if( st->codec->codec_tag == MKTAG( 'm', 'p', '4', 's' ))
{
//This is some stuff for the hint track, lets ignore it!
//Do some mp4 auto detect.
@ -1067,7 +1067,7 @@ static int mov_read_stsd(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
size-=(16);
url_fskip(pb, size); /* The mp4s atom also contians a esds atom that we can skip*/
}
else if( st->codec.codec_tag == MKTAG( 'm', 'p', '4', 'a' ))
else if( st->codec->codec_tag == MKTAG( 'm', 'p', '4', 'a' ))
{
MOV_atom_t a;
int mp4_version;
@ -1076,10 +1076,10 @@ static int mov_read_stsd(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
mp4_version=get_be16(pb);/*version*/
get_be16(pb); /*revesion*/
get_be32(pb);
st->codec.channels = get_be16(pb); /* channels */
st->codec.bits_per_sample = get_be16(pb); /* bits per sample */
st->codec->channels = get_be16(pb); /* channels */
st->codec->bits_per_sample = get_be16(pb); /* bits per sample */
get_be32(pb);
st->codec.sample_rate = get_be16(pb); /* sample rate, not always correct */
st->codec->sample_rate = get_be16(pb); /* sample rate, not always correct */
get_be16(pb);
c->mp4=1;
@ -1096,35 +1096,35 @@ static int mov_read_stsd(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
mov_read_default(c, pb, a);
/* Get correct sample rate from extradata */
if(st->codec.extradata_size) {
if(st->codec->extradata_size) {
const int samplerate_table[] = {
96000, 88200, 64000, 48000, 44100, 32000,
24000, 22050, 16000, 12000, 11025, 8000,
7350, 0, 0, 0
};
unsigned char *px = st->codec.extradata;
unsigned char *px = st->codec->extradata;
// 5 bits objectTypeIndex, 4 bits sampleRateIndex, 4 bits channels
int samplerate_index = ((px[0] & 7) << 1) + ((px[1] >> 7) & 1);
st->codec.sample_rate = samplerate_table[samplerate_index];
st->codec.channels = (px[1] >> 3) & 15;
st->codec->sample_rate = samplerate_table[samplerate_index];
st->codec->channels = (px[1] >> 3) & 15;
}
}
else if( st->codec.codec_tag == MKTAG( 'a', 'l', 'a', 'c' ))
else if( st->codec->codec_tag == MKTAG( 'a', 'l', 'a', 'c' ))
{
/* Handle alac audio tag + special extradata */
get_be32(pb); /* version */
get_be32(pb);
st->codec.channels = get_be16(pb); /* channels */
st->codec.bits_per_sample = get_be16(pb); /* bits per sample */
st->codec->channels = get_be16(pb); /* channels */
st->codec->bits_per_sample = get_be16(pb); /* bits per sample */
get_be32(pb);
st->codec.sample_rate = get_be16(pb);
st->codec->sample_rate = get_be16(pb);
get_be16(pb);
/* fetch the 36-byte extradata needed for alac decoding */
st->codec.extradata_size = 36;
st->codec.extradata = (uint8_t*)
av_mallocz(st->codec.extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
get_buffer(pb, st->codec.extradata, st->codec.extradata_size);
st->codec->extradata_size = 36;
st->codec->extradata = (uint8_t*)
av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
get_buffer(pb, st->codec->extradata, st->codec->extradata_size);
}
else if(size>=(16+20))
{//16 bytes read, reading atleast 20 more
@ -1136,23 +1136,23 @@ static int mov_read_stsd(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
get_be16(pb); /* revision level */
get_be32(pb); /* vendor */
st->codec.channels = get_be16(pb); /* channel count */
st->codec.bits_per_sample = get_be16(pb); /* sample size */
st->codec->channels = get_be16(pb); /* channel count */
st->codec->bits_per_sample = get_be16(pb); /* sample size */
/* handle specific s8 codec */
get_be16(pb); /* compression id = 0*/
get_be16(pb); /* packet size = 0 */
st->codec.sample_rate = ((get_be32(pb) >> 16));
//av_log(NULL, AV_LOG_DEBUG, "CODECID %d %d %.4s\n", st->codec.codec_id, CODEC_ID_PCM_S16BE, (char*)&format);
st->codec->sample_rate = ((get_be32(pb) >> 16));
//av_log(NULL, AV_LOG_DEBUG, "CODECID %d %d %.4s\n", st->codec->codec_id, CODEC_ID_PCM_S16BE, (char*)&format);
switch (st->codec.codec_id) {
switch (st->codec->codec_id) {
case CODEC_ID_PCM_S16BE:
if (st->codec.bits_per_sample == 8)
st->codec.codec_id = CODEC_ID_PCM_S8;
if (st->codec->bits_per_sample == 8)
st->codec->codec_id = CODEC_ID_PCM_S8;
/* fall */
case CODEC_ID_PCM_U8:
st->codec.bit_rate = st->codec.sample_rate * 8;
st->codec->bit_rate = st->codec->sample_rate * 8;
break;
default:
;
@ -1348,8 +1348,8 @@ av_log(NULL, AV_LOG_DEBUG, "track[%i].stts.entries = %i\n", c->fc->nb_streams-1,
}
av_set_pts_info(st, 64, 1, c->streams[c->fc->nb_streams-1]->time_scale);
// st->codec.time_base.num = 1;
// st->codec.time_base.den = c->streams[c->fc->nb_streams-1]->time_scale;
// st->codec->time_base.num = 1;
// st->codec->time_base.den = c->streams[c->fc->nb_streams-1]->time_scale;
st->nb_frames= total_sample_count;
if(duration)
st->duration= duration;
@ -1400,7 +1400,7 @@ static int mov_read_trak(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
sc->sample_to_chunk_index = -1;
st->priv_data = sc;
st->codec.codec_type = CODEC_TYPE_MOV_OTHER;
st->codec->codec_type = CODEC_TYPE_MOV_OTHER;
st->start_time = 0; /* XXX: check */
c->streams[c->fc->nb_streams-1] = sc;
@ -1443,8 +1443,8 @@ static int mov_read_tkhd(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom)
url_fskip(pb, 36); /* display matrix */
/* those are fixed-point */
/*st->codec.width =*/ get_be32(pb) >> 16; /* track width */
/*st->codec.height =*/ get_be32(pb) >> 16; /* track height */
/*st->codec->width =*/ get_be32(pb) >> 16; /* track width */
/*st->codec->height =*/ get_be32(pb) >> 16; /* track height */
return 0;
}
@ -1755,7 +1755,7 @@ static int mov_read_header(AVFormatContext *s, AVFormatParameters *ap)
#if 1
for(i=0; i<s->nb_streams;) {
if(s->streams[i]->codec.codec_type == CODEC_TYPE_MOV_OTHER) {/* not audio, not video, delete */
if(s->streams[i]->codec->codec_type == CODEC_TYPE_MOV_OTHER) {/* not audio, not video, delete */
av_free(s->streams[i]);
for(j=i+1; j<s->nb_streams; j++)
s->streams[j-1] = s->streams[j];
@ -1894,7 +1894,7 @@ again:
{
// I can't figure out why for PCM audio sample_size is always 1
// (it should actually be channels*bits_per_second/8) but it is.
AVCodecContext* cod = &s->streams[sc->ffindex]->codec;
AVCodecContext* cod = s->streams[sc->ffindex]->codec;
if (sc->sample_size == 1 && (cod->codec_id == CODEC_ID_PCM_S16BE || cod->codec_id == CODEC_ID_PCM_S16LE))
foundsize=(sc->sample_to_chunk[i].count*cod->channels*cod->bits_per_sample)/8;
else

14
libavformat/movenc.c
View File

@ -1256,11 +1256,11 @@ int mov_write_ftyp_tag(ByteIOContext *pb, AVFormatContext *s)
static void mov_write_uuidprof_tag(ByteIOContext *pb, AVFormatContext *s)
{
int AudioRate = s->streams[1]->codec.sample_rate;
int FrameRate = ((s->streams[0]->codec.time_base.den) * (0x10000))/ (s->streams[0]->codec.time_base.num);
int AudioRate = s->streams[1]->codec->sample_rate;
int FrameRate = ((s->streams[0]->codec->time_base.den) * (0x10000))/ (s->streams[0]->codec->time_base.num);
//printf("audiorate = %d\n",AudioRate);
//printf("framerate = %d / %d = 0x%x\n",s->streams[0]->codec.time_base.den,s->streams[0]->codec.time_base.num,FrameRate);
//printf("framerate = %d / %d = 0x%x\n",s->streams[0]->codec->time_base.den,s->streams[0]->codec->time_base.num,FrameRate);
put_be32(pb, 0x94 ); /* size */
put_tag(pb, "uuid");
@ -1302,8 +1302,8 @@ static void mov_write_uuidprof_tag(ByteIOContext *pb, AVFormatContext *s)
put_be32(pb, 0xc0 );
put_be32(pb, FrameRate); // was 0xefc29
put_be32(pb, FrameRate ); // was 0xefc29
put_be16(pb, s->streams[0]->codec.width);
put_be16(pb, s->streams[0]->codec.height);
put_be16(pb, s->streams[0]->codec->width);
put_be16(pb, s->streams[0]->codec->height);
put_be32(pb, 0x010001 );
}
@ -1314,7 +1314,7 @@ static int mov_write_header(AVFormatContext *s)
int i;
for(i=0; i<s->nb_streams; i++){
AVCodecContext *c= &s->streams[i]->codec;
AVCodecContext *c= s->streams[i]->codec;
if (c->codec_type == CODEC_TYPE_VIDEO){
if (!codec_get_tag(codec_movvideo_tags, c->codec_id)){
@ -1367,7 +1367,7 @@ static int mov_write_packet(AVFormatContext *s, AVPacket *pkt)
{
MOVContext *mov = s->priv_data;
ByteIOContext *pb = &s->pb;
AVCodecContext *enc = &s->streams[pkt->stream_index]->codec;
AVCodecContext *enc = s->streams[pkt->stream_index]->codec;
MOVTrack* trk = &mov->tracks[pkt->stream_index];
int cl, id;
unsigned int samplesInChunk = 0;

4
libavformat/mp3.c
View File

@ -251,8 +251,8 @@ static int mp3_read_header(AVFormatContext *s,
if (!st)
return AVERROR_NOMEM;
st->codec.codec_type = CODEC_TYPE_AUDIO;
st->codec.codec_id = CODEC_ID_MP3;
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->codec_id = CODEC_ID_MP3;
st->need_parsing = 1;
/* try to get the TAG */

40
libavformat/mpeg.c
View File

@ -360,26 +360,26 @@ static int mpeg_mux_init(AVFormatContext *ctx)
av_set_pts_info(st, 64, 1, 90000);
switch(st->codec.codec_type) {
switch(st->codec->codec_type) {
case CODEC_TYPE_AUDIO:
if (st->codec.codec_id == CODEC_ID_AC3) {
if (st->codec->codec_id == CODEC_ID_AC3) {
stream->id = ac3_id++;
} else if (st->codec.codec_id == CODEC_ID_DTS) {
} else if (st->codec->codec_id == CODEC_ID_DTS) {
stream->id = dts_id++;
} else if (st->codec.codec_id == CODEC_ID_PCM_S16BE) {
} else if (st->codec->codec_id == CODEC_ID_PCM_S16BE) {
stream->id = lpcm_id++;
for(j = 0; j < 4; j++) {
if (lpcm_freq_tab[j] == st->codec.sample_rate)
if (lpcm_freq_tab[j] == st->codec->sample_rate)
break;
}
if (j == 4)
goto fail;
if (st->codec.channels > 8)
if (st->codec->channels > 8)
return -1;
stream->lpcm_header[0] = 0x0c;
stream->lpcm_header[1] = (st->codec.channels - 1) | (j << 4);
stream->lpcm_header[1] = (st->codec->channels - 1) | (j << 4);
stream->lpcm_header[2] = 0x80;
stream->lpcm_align = st->codec.channels * 2;
stream->lpcm_align = st->codec->channels * 2;
} else {
stream->id = mpa_id++;
}
@ -391,8 +391,8 @@ static int mpeg_mux_init(AVFormatContext *ctx)
break;
case CODEC_TYPE_VIDEO:
stream->id = mpv_id++;
if (st->codec.rc_buffer_size)
stream->max_buffer_size = 6*1024 + st->codec.rc_buffer_size/8;
if (st->codec->rc_buffer_size)
stream->max_buffer_size = 6*1024 + st->codec->rc_buffer_size/8;
else
stream->max_buffer_size = 230*1024; //FIXME this is probably too small as default
#if 0
@ -422,10 +422,10 @@ static int mpeg_mux_init(AVFormatContext *ctx)
st = ctx->streams[i];
stream = (StreamInfo*) st->priv_data;
if(st->codec.rc_max_rate || stream->id==VIDEO_ID)
codec_rate= st->codec.rc_max_rate;
if(st->codec->rc_max_rate || stream->id==VIDEO_ID)
codec_rate= st->codec->rc_max_rate;
else
codec_rate= st->codec.bit_rate;
codec_rate= st->codec->bit_rate;
if(!codec_rate)
codec_rate= (1<<21)*8*50/ctx->nb_streams;
@ -1073,7 +1073,7 @@ retry:
/* for subtitle, a single PES packet must be generated,
so we flush after every single subtitle packet */
if(s->packet_size > avail_data && !flush
&& st->codec.codec_type != CODEC_TYPE_SUBTITLE)
&& st->codec->codec_type != CODEC_TYPE_SUBTITLE)
return 0;
if(avail_data==0)
continue;
@ -1183,7 +1183,7 @@ static int mpeg_mux_write_packet(AVFormatContext *ctx, AVPacket *pkt)
int64_t pts, dts;
PacketDesc *pkt_desc;
const int preload= av_rescale(ctx->preload, 90000, AV_TIME_BASE);
const int is_iframe = st->codec.codec_type == CODEC_TYPE_VIDEO && (pkt->flags & PKT_FLAG_KEY);
const int is_iframe = st->codec->codec_type == CODEC_TYPE_VIDEO && (pkt->flags & PKT_FLAG_KEY);
pts= pkt->pts;
dts= pkt->dts;
@ -1634,8 +1634,8 @@ static int mpegps_read_packet(AVFormatContext *s,
st = av_new_stream(s, startcode);
if (!st)
goto skip;
st->codec.codec_type = type;
st->codec.codec_id = codec_id;
st->codec->codec_type = type;
st->codec->codec_id = codec_id;
if (codec_id != CODEC_ID_PCM_S16BE)
st->need_parsing = 1;
found:
@ -1653,9 +1653,9 @@ static int mpegps_read_packet(AVFormatContext *s,
get_byte(&s->pb); /* dynamic range control (0x80 = off) */
len -= 3;
freq = (b1 >> 4) & 3;
st->codec.sample_rate = lpcm_freq_tab[freq];
st->codec.channels = 1 + (b1 & 7);
st->codec.bit_rate = st->codec.channels * st->codec.sample_rate * 2;
st->codec->sample_rate = lpcm_freq_tab[freq];
st->codec->channels = 1 + (b1 & 7);
st->codec->bit_rate = st->codec->channels * st->codec->sample_rate * 2;
}
av_new_packet(pkt, len);
get_buffer(&s->pb, pkt->data, pkt->size);

12
libavformat/mpegts.c
View File

@ -493,7 +493,7 @@ static void pmt_cb(void *opaque, const uint8_t *section, int section_len)
}
if (stream_type == STREAM_TYPE_SUBTITLE_DVB) {
st->codec.sub_id = (anc_page << 16) | comp_page;
st->codec->sub_id = (anc_page << 16) | comp_page;
}
}
}
@ -921,8 +921,8 @@ static AVStream* new_pes_av_stream(PESContext *pes, uint32_t code)
if (st) {
av_set_pts_info(st, 33, 1, 90000);
st->priv_data = pes;
st->codec.codec_type = codec_type;
st->codec.codec_id = codec_id;
st->codec->codec_type = codec_type;
st->codec->codec_id = codec_id;
st->need_parsing = 1;
pes->st = st;
}
@ -1253,8 +1253,8 @@ static int mpegts_read_header(AVFormatContext *s,
if (!st)
goto fail;
av_set_pts_info(st, 60, 1, 27000000);
st->codec.codec_type = CODEC_TYPE_DATA;
st->codec.codec_id = CODEC_ID_MPEG2TS;
st->codec->codec_type = CODEC_TYPE_DATA;
st->codec->codec_id = CODEC_ID_MPEG2TS;
/* we iterate until we find two PCRs to estimate the bitrate */
pcr_pid = -1;
@ -1283,7 +1283,7 @@ static int mpegts_read_header(AVFormatContext *s,
ts->pcr_incr = (pcrs[1] - pcrs[0]) / (packet_count[1] - packet_count[0]);
ts->cur_pcr = pcrs[0] - ts->pcr_incr * packet_count[0];
s->bit_rate = (TS_PACKET_SIZE * 8) * 27e6 / ts->pcr_incr;
st->codec.bit_rate = s->bit_rate;
st->codec->bit_rate = s->bit_rate;
st->start_time = ts->cur_pcr;
#if 0
printf("start=%0.3f pcr=%0.3f incr=%d\n",

22
libavformat/mpegtsenc.c
View File

@ -262,7 +262,7 @@ static void mpegts_write_pmt(AVFormatContext *s, MpegTSService *service)
for(i = 0; i < s->nb_streams; i++) {
AVStream *st = s->streams[i];
MpegTSWriteStream *ts_st = st->priv_data;
switch(st->codec.codec_id) {
switch(st->codec->codec_id) {
case CODEC_ID_MPEG1VIDEO:
case CODEC_ID_MPEG2VIDEO:
stream_type = STREAM_TYPE_VIDEO_MPEG2;
@ -293,7 +293,7 @@ static void mpegts_write_pmt(AVFormatContext *s, MpegTSService *service)
q += 2; /* patched after */
/* write optional descriptors here */
switch(st->codec.codec_type) {
switch(st->codec->codec_type) {
case CODEC_TYPE_AUDIO:
if (strlen(st->language) == 3) {
*q++ = 0x0a; /* ISO 639 language descriptor */
@ -452,10 +452,10 @@ static int mpegts_write_header(AVFormatContext *s)
ts_st->pid = DEFAULT_START_PID + i;
ts_st->payload_pts = AV_NOPTS_VALUE;
/* update PCR pid by using the first video stream */
if (st->codec.codec_type == CODEC_TYPE_VIDEO &&
if (st->codec->codec_type == CODEC_TYPE_VIDEO &&
service->pcr_pid == 0x1fff)
service->pcr_pid = ts_st->pid;
total_bit_rate += st->codec.bit_rate;
total_bit_rate += st->codec->bit_rate;
}
/* if no video stream, use the first stream as PCR */
@ -570,15 +570,15 @@ static void mpegts_write_pes(AVFormatContext *s, AVStream *st,
*q++ = 0x00;
*q++ = 0x01;
private_code = 0;
if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
*q++ = 0xe0;
} else if (st->codec.codec_type == CODEC_TYPE_AUDIO &&
(st->codec.codec_id == CODEC_ID_MP2 ||
st->codec.codec_id == CODEC_ID_MP3)) {
} else if (st->codec->codec_type == CODEC_TYPE_AUDIO &&
(st->codec->codec_id == CODEC_ID_MP2 ||
st->codec->codec_id == CODEC_ID_MP3)) {
*q++ = 0xc0;
} else {
*q++ = 0xbd;
if (st->codec.codec_type == CODEC_TYPE_SUBTITLE) {
if (st->codec->codec_type == CODEC_TYPE_SUBTITLE) {
private_code = 0x20;
}
}
@ -593,7 +593,7 @@ static void mpegts_write_pes(AVFormatContext *s, AVStream *st,
*q++ = len;
val = 0x80;
/* data alignment indicator is required for subtitle data */
if (st->codec.codec_type == CODEC_TYPE_SUBTITLE)
if (st->codec->codec_type == CODEC_TYPE_SUBTITLE)
val |= 0x04;
*q++ = val;
if (pts != AV_NOPTS_VALUE) {
@ -660,7 +660,7 @@ static int mpegts_write_packet(AVFormatContext *s, AVPacket *pkt)
MpegTSWriteStream *ts_st = st->priv_data;
int len, max_payload_size;
if (st->codec.codec_type == CODEC_TYPE_SUBTITLE) {
if (st->codec->codec_type == CODEC_TYPE_SUBTITLE) {
/* for subtitle, a single PES packet must be generated */
mpegts_write_pes(s, st, buf, size, pkt->pts);
return 0;

38
libavformat/nsvdec.c
View File

@ -439,12 +439,12 @@ static int nsv_parse_NSVs_header(AVFormatContext *s, AVFormatParameters *ap)
if (!nst)
goto fail;
st->priv_data = nst;
st->codec.codec_type = CODEC_TYPE_VIDEO;
st->codec.codec_tag = vtag;
st->codec.codec_id = codec_get_id(nsv_codec_video_tags, vtag);
st->codec.width = vwidth;
st->codec.height = vheight;
st->codec.bits_per_sample = 24; /* depth XXX */
st->codec->codec_type = CODEC_TYPE_VIDEO;
st->codec->codec_tag = vtag;
st->codec->codec_id = codec_get_id(nsv_codec_video_tags, vtag);
st->codec->width = vwidth;
st->codec->height = vheight;
st->codec->bits_per_sample = 24; /* depth XXX */
av_set_pts_info(st, 64, framerate.den, framerate.num);
st->start_time = 0;
@ -460,17 +460,17 @@ static int nsv_parse_NSVs_header(AVFormatContext *s, AVFormatParameters *ap)
if (!nst)
goto fail;
st->priv_data = nst;
st->codec.codec_type = CODEC_TYPE_AUDIO;
st->codec.codec_tag = atag;
st->codec.codec_id = codec_get_id(nsv_codec_audio_tags, atag);
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->codec_tag = atag;
st->codec->codec_id = codec_get_id(nsv_codec_audio_tags, atag);
st->start_time = 0;
// st->duration = nsv->duration; //FIXME
st->need_parsing = 1; /* for PCM we will read a chunk later and put correct info */
/* XXX:FIXME */
//st->codec.channels = 2; //XXX:channels;
//st->codec.sample_rate = 1000;
//av_set_pts_info(st, 64, 1, st->codec.sample_rate);
//st->codec->channels = 2; //XXX:channels;
//st->codec->sample_rate = 1000;
//av_set_pts_info(st, 64, 1, st->codec->sample_rate);
#endif
}
@ -606,7 +606,7 @@ null_chunk_retry:
pkt = &nsv->ahead[NSV_ST_AUDIO];
/* read raw audio specific header on the first audio chunk... */
/* on ALL audio chunks ?? seems so! */
if (asize && st[NSV_ST_AUDIO]->codec.codec_tag == MKTAG('P', 'C', 'M', ' ')/* && fill_header*/) {
if (asize && st[NSV_ST_AUDIO]->codec->codec_tag == MKTAG('P', 'C', 'M', ' ')/* && fill_header*/) {
uint8_t bps;
uint8_t channels;
uint16_t samplerate;
@ -622,13 +622,13 @@ null_chunk_retry:
}
bps /= channels; // ???
if (bps == 8)
st[NSV_ST_AUDIO]->codec.codec_id = CODEC_ID_PCM_U8;
st[NSV_ST_AUDIO]->codec->codec_id = CODEC_ID_PCM_U8;
samplerate /= 4;/* UGH ??? XXX */
channels = 1;
st[NSV_ST_AUDIO]->codec.channels = channels;
st[NSV_ST_AUDIO]->codec.sample_rate = samplerate;
st[NSV_ST_AUDIO]->codec->channels = channels;
st[NSV_ST_AUDIO]->codec->sample_rate = samplerate;
av_set_pts_info(st[NSV_ST_AUDIO], 64, 1,
st[NSV_ST_AUDIO]->codec.sample_rate);
st[NSV_ST_AUDIO]->codec->sample_rate);
PRINT(("NSV RAWAUDIO: bps %d, nchan %d, srate %ld\n", bps, channels, samplerate));
}
}
@ -704,8 +704,8 @@ static int nsv_read_close(AVFormatContext *s)
av_free(ast->index_entries);
av_free(ast);
}
av_free(st->codec.extradata);
av_free(st->codec.palctrl);
av_free(st->codec->extradata);
av_free(st->codec->palctrl);
}
#endif

54
libavformat/nut.c
View File

@ -155,7 +155,7 @@ static void build_frame_code(AVFormatContext *s){
for(stream_id= 0; stream_id<s->nb_streams; stream_id++){
int start2= start + (end-start)*stream_id / s->nb_streams;
int end2 = start + (end-start)*(stream_id+1) / s->nb_streams;
AVCodecContext *codec = &s->streams[stream_id]->codec;
AVCodecContext *codec = s->streams[stream_id]->codec;
int is_audio= codec->codec_type == CODEC_TYPE_AUDIO;
int intra_only= /*codec->intra_only || */is_audio;
int pred_count;
@ -579,7 +579,7 @@ static int nut_write_header(AVFormatContext *s)
{
int nom, denom, ssize;
codec = &s->streams[i]->codec;
codec = s->streams[i]->codec;
put_be64(bc, STREAM_STARTCODE);
put_packetheader(nut, bc, 120 + codec->extradata_size, 1);
@ -674,7 +674,7 @@ static int nut_write_header(AVFormatContext *s)
put_str(bc, s->copyright);
}
/* encoder */
if(!(s->streams[0]->codec.flags & CODEC_FLAG_BITEXACT)){
if(!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)){
put_v(bc, 13); /* type */
put_str(bc, LIBAVFORMAT_IDENT);
}
@ -707,7 +707,7 @@ static int nut_write_packet(AVFormatContext *s, AVPacket *pkt)
int size= pkt->size;
int stream_index= pkt->stream_index;
enc = &s->streams[stream_index]->codec;
enc = s->streams[stream_index]->codec;
key_frame = !!(pkt->flags & PKT_FLAG_KEY);
frame_type=0;
@ -949,27 +949,27 @@ static int decode_stream_header(NUTContext *nut){
class = get_v(bc);
tmp = get_vb(bc);
st->codec.codec_tag= tmp;
st->codec->codec_tag= tmp;
switch(class)
{
case 0:
st->codec.codec_type = CODEC_TYPE_VIDEO;
st->codec.codec_id = codec_get_bmp_id(tmp);
if (st->codec.codec_id == CODEC_ID_NONE)
st->codec->codec_type = CODEC_TYPE_VIDEO;
st->codec->codec_id = codec_get_bmp_id(tmp);
if (st->codec->codec_id == CODEC_ID_NONE)
av_log(s, AV_LOG_ERROR, "Unknown codec?!\n");
break;
case 1:
case 32: //compatibility
st->codec.codec_type = CODEC_TYPE_AUDIO;
st->codec.codec_id = codec_get_wav_id(tmp);
if (st->codec.codec_id == CODEC_ID_NONE)
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->codec_id = codec_get_wav_id(tmp);
if (st->codec->codec_id == CODEC_ID_NONE)
av_log(s, AV_LOG_ERROR, "Unknown codec?!\n");
break;
case 2:
// st->codec.codec_type = CODEC_TYPE_TEXT;
// st->codec->codec_type = CODEC_TYPE_TEXT;
// break;
case 3:
st->codec.codec_type = CODEC_TYPE_DATA;
st->codec->codec_type = CODEC_TYPE_DATA;
break;
default:
av_log(s, AV_LOG_ERROR, "Unknown stream class (%d)\n", class);
@ -980,33 +980,33 @@ static int decode_stream_header(NUTContext *nut){
nom = get_v(bc);
denom = get_v(bc);
nut->stream[stream_id].msb_timestamp_shift = get_v(bc);
st->codec.has_b_frames=
st->codec->has_b_frames=
nut->stream[stream_id].decode_delay= get_v(bc);
get_byte(bc); /* flags */
/* codec specific data headers */
while(get_v(bc) != 0){
st->codec.extradata_size= get_v(bc);
if((unsigned)st->codec.extradata_size > (1<<30))
st->codec->extradata_size= get_v(bc);
if((unsigned)st->codec->extradata_size > (1<<30))
return -1;
st->codec.extradata= av_mallocz(st->codec.extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
get_buffer(bc, st->codec.extradata, st->codec.extradata_size);
st->codec->extradata= av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
get_buffer(bc, st->codec->extradata, st->codec->extradata_size);
// url_fskip(bc, get_v(bc));
}
if (st->codec.codec_type == CODEC_TYPE_VIDEO) /* VIDEO */
if (st->codec->codec_type == CODEC_TYPE_VIDEO) /* VIDEO */
{
st->codec.width = get_v(bc);
st->codec.height = get_v(bc);
st->codec.sample_aspect_ratio.num= get_v(bc);
st->codec.sample_aspect_ratio.den= get_v(bc);
st->codec->width = get_v(bc);
st->codec->height = get_v(bc);
st->codec->sample_aspect_ratio.num= get_v(bc);
st->codec->sample_aspect_ratio.den= get_v(bc);
get_v(bc); /* csp type */
}
if (st->codec.codec_type == CODEC_TYPE_AUDIO) /* AUDIO */
if (st->codec->codec_type == CODEC_TYPE_AUDIO) /* AUDIO */
{
st->codec.sample_rate = get_v(bc);
st->codec->sample_rate = get_v(bc);
get_v(bc); // samplerate_den
st->codec.channels = get_v(bc);
st->codec->channels = get_v(bc);
}
if(check_checksum(bc)){
av_log(s, AV_LOG_ERROR, "Stream header %d checksum mismatch\n", stream_id);
@ -1407,7 +1407,7 @@ static int nut_read_close(AVFormatContext *s)
int i;
for(i=0;i<s->nb_streams;i++) {
av_freep(&s->streams[i]->codec.extradata);
av_freep(&s->streams[i]->codec->extradata);
}
av_freep(&nut->stream);

4
libavformat/ogg.c
View File

@ -39,7 +39,7 @@ static int ogg_write_header(AVFormatContext *avfcontext)
ogg_stream_init(&context->os, 31415);
for(n = 0 ; n < avfcontext->nb_streams ; n++) {
AVCodecContext *codec = &avfcontext->streams[n]->codec;
AVCodecContext *codec = avfcontext->streams[n]->codec;
uint8_t *p= codec->extradata;
av_set_pts_info(avfcontext->streams[n], 60, 1, AV_TIME_BASE);
@ -65,7 +65,7 @@ static int ogg_write_header(AVFormatContext *avfcontext)
static int ogg_write_packet(AVFormatContext *avfcontext, AVPacket *pkt)
{
OggContext *context = avfcontext->priv_data ;
AVCodecContext *avctx= &avfcontext->streams[pkt->stream_index]->codec;
AVCodecContext *avctx= avfcontext->streams[pkt->stream_index]->codec;
ogg_packet *op= &context->op;
ogg_page og ;
int64_t pts;

4
libavformat/ogg2.c
View File

@ -430,7 +430,7 @@ ogg_gptopts (AVFormatContext * s, int i, uint64_t gp)
ogg_t *ogg = s->priv_data;
ogg_stream_t *os = ogg->streams + i;
AVStream *st = s->streams[i];
AVCodecContext *codec = &st->codec;
AVCodecContext *codec = st->codec;
uint64_t pts = AV_NOPTS_VALUE;
if(os->codec->gptopts){
@ -537,7 +537,7 @@ ogg_read_close (AVFormatContext * s)
for (i = 0; i < ogg->nstreams; i++){
av_free (ogg->streams[i].buf);
av_free (ogg->streams[i].private);
av_freep (&s->streams[i]->codec.extradata);
av_freep (&s->streams[i]->codec->extradata);
}
av_free (ogg->streams);
return 0;

14
libavformat/oggparseflac.c
View File

@ -52,17 +52,17 @@ flac_header (AVFormatContext * s, int idx)
skip_bits(&gb, 16*2+24*2);
st->codec.sample_rate = get_bits_long(&gb, 20);
st->codec.channels = get_bits(&gb, 3) + 1;
st->codec->sample_rate = get_bits_long(&gb, 20);
st->codec->channels = get_bits(&gb, 3) + 1;
st->codec.codec_type = CODEC_TYPE_AUDIO;
st->codec.codec_id = CODEC_ID_FLAC;
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->codec_id = CODEC_ID_FLAC;
st->codec.extradata =
st->codec->extradata =
av_malloc(FLAC_STREAMINFO_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
memcpy (st->codec.extradata, os->buf + os->pstart + 5 + 4 + 4 + 4,
memcpy (st->codec->extradata, os->buf + os->pstart + 5 + 4 + 4 + 4,
FLAC_STREAMINFO_SIZE);
st->codec.extradata_size = FLAC_STREAMINFO_SIZE;
st->codec->extradata_size = FLAC_STREAMINFO_SIZE;
} else if (mdt == 4) {
vorbis_comment (s, os->buf + os->pstart + 4, os->psize - 4);
}

28
libavformat/oggparsetheora.c
View File

@ -40,7 +40,7 @@ theora_header (AVFormatContext * s, int idx)
ogg_stream_t *os = ogg->streams + idx;
AVStream *st = s->streams[idx];
theora_params_t *thp = os->private;
int cds = st->codec.extradata_size + os->psize + 2;
int cds = st->codec->extradata_size + os->psize + 2;
uint8_t *cdp;
if(!(os->buf[os->pstart] & 0x80))
@ -62,33 +62,33 @@ theora_header (AVFormatContext * s, int idx)
return -1;
skip_bits(&gb, 8); /* revision */
st->codec.width = get_bits(&gb, 16) << 4;
st->codec.height = get_bits(&gb, 16) << 4;
st->codec->width = get_bits(&gb, 16) << 4;
st->codec->height = get_bits(&gb, 16) << 4;
skip_bits(&gb, 64);
st->codec.time_base.den = get_bits(&gb, 32);
st->codec.time_base.num = get_bits(&gb, 32);
st->codec->time_base.den = get_bits(&gb, 32);
st->codec->time_base.num = get_bits(&gb, 32);
st->codec.sample_aspect_ratio.num = get_bits(&gb, 24);
st->codec.sample_aspect_ratio.den = get_bits(&gb, 24);
st->codec->sample_aspect_ratio.num = get_bits(&gb, 24);
st->codec->sample_aspect_ratio.den = get_bits(&gb, 24);
skip_bits(&gb, 38);
thp->gpshift = get_bits(&gb, 5);
thp->gpmask = (1 << thp->gpshift) - 1;
st->codec.codec_type = CODEC_TYPE_VIDEO;
st->codec.codec_id = CODEC_ID_THEORA;
st->codec->codec_type = CODEC_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_THEORA;
} else if (os->buf[os->pstart] == 0x83) {
vorbis_comment (s, os->buf + os->pstart + 7, os->psize - 8);
}
st->codec.extradata = av_realloc (st->codec.extradata, cds);
cdp = st->codec.extradata + st->codec.extradata_size;
st->codec->extradata = av_realloc (st->codec->extradata, cds);
cdp = st->codec->extradata + st->codec->extradata_size;
*cdp++ = os->psize >> 8;
*cdp++ = os->psize & 0xff;
memcpy (cdp, os->buf + os->pstart, os->psize);
st->codec.extradata_size = cds;
st->codec->extradata_size = cds;
return 1;
}
@ -103,8 +103,8 @@ theora_gptopts(AVFormatContext *ctx, int idx, uint64_t gp)
uint64_t iframe = gp >> thp->gpshift;
uint64_t pframe = gp & thp->gpmask;
return (iframe + pframe) * AV_TIME_BASE * st->codec.time_base.num /
st->codec.time_base.den;
return (iframe + pframe) * AV_TIME_BASE * st->codec->time_base.num /
st->codec->time_base.den;
}
ogg_codec_t theora_codec = {

14
libavformat/oggparsevorbis.c
View File

@ -178,19 +178,19 @@ vorbis_header (AVFormatContext * s, int idx)
memcpy(priv->packet[os->seq], os->buf + os->pstart, os->psize);
if (os->buf[os->pstart] == 1) {
uint8_t *p = os->buf + os->pstart + 11; //skip up to the audio channels
st->codec.channels = *p++;
st->codec.sample_rate = le2me_32 (unaligned32 (p));
st->codec->channels = *p++;
st->codec->sample_rate = le2me_32 (unaligned32 (p));
p += 8; //skip maximum and and nominal bitrate
st->codec.bit_rate = le2me_32 (unaligned32 (p)); //Minimum bitrate
st->codec->bit_rate = le2me_32 (unaligned32 (p)); //Minimum bitrate
st->codec.codec_type = CODEC_TYPE_AUDIO;
st->codec.codec_id = CODEC_ID_VORBIS;
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->codec_id = CODEC_ID_VORBIS;
} else if (os->buf[os->pstart] == 3) {
vorbis_comment (s, os->buf + os->pstart + 7, os->psize - 8);
} else {
st->codec.extradata_size =
fixup_vorbis_headers(s, priv, &st->codec.extradata);
st->codec->extradata_size =
fixup_vorbis_headers(s, priv, &st->codec->extradata);
}
return os->seq < 3;

24
libavformat/psxstr.c
View File

@ -182,11 +182,11 @@ static int str_read_header(AVFormatContext *s,
str->channels[channel].video_stream_index = st->index;
st->codec.codec_type = CODEC_TYPE_VIDEO;
st->codec.codec_id = CODEC_ID_MDEC;
st->codec.codec_tag = 0; /* no fourcc */
st->codec.width = str->channels[channel].width;
st->codec.height = str->channels[channel].height;
st->codec->codec_type = CODEC_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_MDEC;
st->codec->codec_tag = 0; /* no fourcc */
st->codec->width = str->channels[channel].width;
st->codec->height = str->channels[channel].height;
}
break;
@ -212,13 +212,13 @@ static int str_read_header(AVFormatContext *s,
str->channels[channel].audio_stream_index = st->index;
fmt = sector[0x13];
st->codec.codec_type = CODEC_TYPE_AUDIO;
st->codec.codec_id = CODEC_ID_ADPCM_XA;
st->codec.codec_tag = 0; /* no fourcc */
st->codec.channels = (fmt&1)?2:1;
st->codec.sample_rate = (fmt&4)?18900:37800;
// st->codec.bit_rate = 0; //FIXME;
st->codec.block_align = 128;
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->codec_id = CODEC_ID_ADPCM_XA;
st->codec->codec_tag = 0; /* no fourcc */
st->codec->channels = (fmt&1)?2:1;
st->codec->sample_rate = (fmt&4)?18900:37800;
// st->codec->bit_rate = 0; //FIXME;
st->codec->block_align = 128;
}
break;

66
libavformat/raw.c
View File

@ -50,25 +50,25 @@ static int raw_read_header(AVFormatContext *s, AVFormatParameters *ap)
if (ap) {
id = s->iformat->value;
if (id == CODEC_ID_RAWVIDEO) {
st->codec.codec_type = CODEC_TYPE_VIDEO;
st->codec->codec_type = CODEC_TYPE_VIDEO;
} else {
st->codec.codec_type = CODEC_TYPE_AUDIO;
st->codec->codec_type = CODEC_TYPE_AUDIO;
}
st->codec.codec_id = id;
st->codec->codec_id = id;
switch(st->codec.codec_type) {
switch(st->codec->codec_type) {
case CODEC_TYPE_AUDIO:
st->codec.sample_rate = ap->sample_rate;
st->codec.channels = ap->channels;
av_set_pts_info(st, 64, 1, st->codec.sample_rate);
st->codec->sample_rate = ap->sample_rate;
st->codec->channels = ap->channels;
av_set_pts_info(st, 64, 1, st->codec->sample_rate);
break;
case CODEC_TYPE_VIDEO:
av_set_pts_info(st, 64, ap->time_base.num, ap->time_base.den);
st->codec.width = ap->width;
st->codec.height = ap->height;
st->codec.pix_fmt = ap->pix_fmt;
if(st->codec.pix_fmt == PIX_FMT_NONE)
st->codec.pix_fmt= PIX_FMT_YUV420P;
st->codec->width = ap->width;
st->codec->height = ap->height;
st->codec->pix_fmt = ap->pix_fmt;
if(st->codec->pix_fmt == PIX_FMT_NONE)
st->codec->pix_fmt= PIX_FMT_YUV420P;
break;
default:
return -1;
@ -133,24 +133,24 @@ int pcm_read_seek(AVFormatContext *s,
int64_t pos;
st = s->streams[0];
switch(st->codec.codec_id) {
switch(st->codec->codec_id) {
case CODEC_ID_PCM_S16LE:
case CODEC_ID_PCM_S16BE:
case CODEC_ID_PCM_U16LE:
case CODEC_ID_PCM_U16BE:
block_align = 2 * st->codec.channels;
byte_rate = block_align * st->codec.sample_rate;
block_align = 2 * st->codec->channels;
byte_rate = block_align * st->codec->sample_rate;
break;
case CODEC_ID_PCM_S8:
case CODEC_ID_PCM_U8:
case CODEC_ID_PCM_MULAW:
case CODEC_ID_PCM_ALAW:
block_align = st->codec.channels;
byte_rate = block_align * st->codec.sample_rate;
block_align = st->codec->channels;
byte_rate = block_align * st->codec->sample_rate;
break;
default:
block_align = st->codec.block_align;
byte_rate = st->codec.bit_rate / 8;
block_align = st->codec->block_align;
byte_rate = st->codec->bit_rate / 8;
break;
}
@ -180,8 +180,8 @@ static int ac3_read_header(AVFormatContext *s,
if (!st)
return AVERROR_NOMEM;
st->codec.codec_type = CODEC_TYPE_AUDIO;
st->codec.codec_id = CODEC_ID_AC3;
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->codec_id = CODEC_ID_AC3;
st->need_parsing = 1;
/* the parameters will be extracted from the compressed bitstream */
return 0;
@ -195,8 +195,8 @@ static int shorten_read_header(AVFormatContext *s,
st = av_new_stream(s, 0);
if (!st)
return AVERROR_NOMEM;
st->codec.codec_type = CODEC_TYPE_AUDIO;
st->codec.codec_id = CODEC_ID_SHORTEN;
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->codec_id = CODEC_ID_SHORTEN;
st->need_parsing = 1;
/* the parameters will be extracted from the compressed bitstream */
return 0;
@ -212,8 +212,8 @@ static int dts_read_header(AVFormatContext *s,
if (!st)
return AVERROR_NOMEM;
st->codec.codec_type = CODEC_TYPE_AUDIO;
st->codec.codec_id = CODEC_ID_DTS;
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->codec_id = CODEC_ID_DTS;
st->need_parsing = 1;
/* the parameters will be extracted from the compressed bitstream */
return 0;
@ -229,17 +229,17 @@ static int video_read_header(AVFormatContext *s,
if (!st)
return AVERROR_NOMEM;
st->codec.codec_type = CODEC_TYPE_VIDEO;
st->codec.codec_id = s->iformat->value;
st->codec->codec_type = CODEC_TYPE_VIDEO;
st->codec->codec_id = s->iformat->value;
st->need_parsing = 1;
/* for mjpeg, specify frame rate */
/* for mpeg4 specify it too (most mpeg4 streams dont have the fixed_vop_rate set ...)*/
if (ap && ap->time_base.num) {
av_set_pts_info(st, 64, ap->time_base.num, ap->time_base.den);
} else if ( st->codec.codec_id == CODEC_ID_MJPEG ||
st->codec.codec_id == CODEC_ID_MPEG4 ||
st->codec.codec_id == CODEC_ID_H264) {
} else if ( st->codec->codec_id == CODEC_ID_MJPEG ||
st->codec->codec_id == CODEC_ID_MPEG4 ||
st->codec->codec_id == CODEC_ID_H264) {
av_set_pts_info(st, 64, 1, 25);
}
@ -609,10 +609,10 @@ static int rawvideo_read_packet(AVFormatContext *s, AVPacket *pkt)
int packet_size, ret, width, height;
AVStream *st = s->streams[0];
width = st->codec.width;
height = st->codec.height;
width = st->codec->width;
height = st->codec->height;
packet_size = avpicture_get_size(st->codec.pix_fmt, width, height);
packet_size = avpicture_get_size(st->codec->pix_fmt, width, height);
if (packet_size < 0)
return -1;

96
libavformat/rm.c
View File

@ -298,7 +298,7 @@ static int rm_write_header(AVFormatContext *s)
for(n=0;n<s->nb_streams;n++) {
s->streams[n]->id = n;
codec = &s->streams[n]->codec;
codec = s->streams[n]->codec;
stream = &rm->streams[n];
memset(stream, 0, sizeof(StreamInfo));
stream->num = n;
@ -399,7 +399,7 @@ static int rm_write_video(AVFormatContext *s, const uint8_t *buf, int size, int
static int rm_write_packet(AVFormatContext *s, AVPacket *pkt)
{
if (s->streams[pkt->stream_index]->codec.codec_type ==
if (s->streams[pkt->stream_index]->codec->codec_type ==
CODEC_TYPE_AUDIO)
return rm_write_audio(s, pkt->data, pkt->size, pkt->flags);
else
@ -495,10 +495,10 @@ static void rm_read_audio_stream_info(AVFormatContext *s, AVStream *st,
get_str8(pb, s->comment, sizeof(s->comment));
get_byte(pb);
get_str8(pb, buf, sizeof(buf));
st->codec.sample_rate = 8000;
st->codec.channels = 1;
st->codec.codec_type = CODEC_TYPE_AUDIO;
st->codec.codec_id = CODEC_ID_RA_144;
st->codec->sample_rate = 8000;
st->codec->channels = 1;
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->codec_id = CODEC_ID_RA_144;
} else {
int flavor, sub_packet_h, coded_framesize;
/* old version (4) */
@ -512,30 +512,30 @@ static void rm_read_audio_stream_info(AVFormatContext *s, AVStream *st,
get_be32(pb); /* ??? */
get_be32(pb); /* ??? */
sub_packet_h= get_be16(pb); /* 1 */
st->codec.block_align= get_be16(pb); /* frame size */
st->codec->block_align= get_be16(pb); /* frame size */
get_be16(pb); /* sub packet size */
get_be16(pb); /* ??? */
st->codec.sample_rate = get_be16(pb);
st->codec->sample_rate = get_be16(pb);
get_be32(pb);
st->codec.channels = get_be16(pb);
st->codec->channels = get_be16(pb);
get_str8(pb, buf, sizeof(buf)); /* desc */
get_str8(pb, buf, sizeof(buf)); /* desc */
st->codec.codec_type = CODEC_TYPE_AUDIO;
st->codec->codec_type = CODEC_TYPE_AUDIO;
if (!strcmp(buf, "dnet")) {
st->codec.codec_id = CODEC_ID_AC3;
st->codec->codec_id = CODEC_ID_AC3;
} else if (!strcmp(buf, "28_8")) {
st->codec.codec_id = CODEC_ID_RA_288;
st->codec.extradata_size= 10;
st->codec.extradata= av_mallocz(st->codec.extradata_size);
st->codec->codec_id = CODEC_ID_RA_288;
st->codec->extradata_size= 10;
st->codec->extradata= av_mallocz(st->codec->extradata_size);
/* this is completly braindead and broken, the idiot who added this codec and endianness
specific reordering to mplayer and libavcodec/ra288.c should be drowned in a see of cola */
//FIXME pass the unpermutated extradata
((uint16_t*)st->codec.extradata)[1]= sub_packet_h;
((uint16_t*)st->codec.extradata)[2]= flavor;
((uint16_t*)st->codec.extradata)[3]= coded_framesize;
((uint16_t*)st->codec->extradata)[1]= sub_packet_h;
((uint16_t*)st->codec->extradata)[2]= flavor;
((uint16_t*)st->codec->extradata)[3]= coded_framesize;
} else {
st->codec.codec_id = CODEC_ID_NONE;
pstrcpy(st->codec.codec_name, sizeof(st->codec.codec_name),
st->codec->codec_id = CODEC_ID_NONE;
pstrcpy(st->codec->codec_name, sizeof(st->codec->codec_name),
buf);
}
if (read_all) {
@ -635,7 +635,7 @@ static int rm_read_header(AVFormatContext *s, AVFormatParameters *ap)
goto fail;
st->id = get_be16(pb);
get_be32(pb); /* max bit rate */
st->codec.bit_rate = get_be32(pb); /* bit rate */
st->codec->bit_rate = get_be32(pb); /* bit rate */
get_be32(pb); /* max packet size */
get_be32(pb); /* avg packet size */
start_time = get_be32(pb); /* start time */
@ -647,7 +647,7 @@ static int rm_read_header(AVFormatContext *s, AVFormatParameters *ap)
get_str8(pb, buf, sizeof(buf)); /* mimetype */
codec_data_size = get_be32(pb);
codec_pos = url_ftell(pb);
st->codec.codec_type = CODEC_TYPE_DATA;
st->codec->codec_type = CODEC_TYPE_DATA;
av_set_pts_info(st, 64, 1, 1000);
v = get_be32(pb);
@ -658,43 +658,43 @@ static int rm_read_header(AVFormatContext *s, AVFormatParameters *ap)
int fps, fps2;
if (get_le32(pb) != MKTAG('V', 'I', 'D', 'O')) {
fail1:
av_log(&st->codec, AV_LOG_ERROR, "Unsupported video codec\n");
av_log(st->codec, AV_LOG_ERROR, "Unsupported video codec\n");
goto skip;
}
st->codec.codec_tag = get_le32(pb);
// av_log(NULL, AV_LOG_DEBUG, "%X %X\n", st->codec.codec_tag, MKTAG('R', 'V', '2', '0'));
if ( st->codec.codec_tag != MKTAG('R', 'V', '1', '0')
&& st->codec.codec_tag != MKTAG('R', 'V', '2', '0')
&& st->codec.codec_tag != MKTAG('R', 'V', '3', '0')
&& st->codec.codec_tag != MKTAG('R', 'V', '4', '0'))
st->codec->codec_tag = get_le32(pb);
// av_log(NULL, AV_LOG_DEBUG, "%X %X\n", st->codec->codec_tag, MKTAG('R', 'V', '2', '0'));
if ( st->codec->codec_tag != MKTAG('R', 'V', '1', '0')
&& st->codec->codec_tag != MKTAG('R', 'V', '2', '0')
&& st->codec->codec_tag != MKTAG('R', 'V', '3', '0')
&& st->codec->codec_tag != MKTAG('R', 'V', '4', '0'))
goto fail1;
st->codec.width = get_be16(pb);
st->codec.height = get_be16(pb);
st->codec.time_base.num= 1;
st->codec->width = get_be16(pb);
st->codec->height = get_be16(pb);
st->codec->time_base.num= 1;
fps= get_be16(pb);
st->codec.codec_type = CODEC_TYPE_VIDEO;
st->codec->codec_type = CODEC_TYPE_VIDEO;
get_be32(pb);
fps2= get_be16(pb);
get_be16(pb);
st->codec.extradata_size= codec_data_size - (url_ftell(pb) - codec_pos);
st->codec.extradata= av_malloc(st->codec.extradata_size);
get_buffer(pb, st->codec.extradata, st->codec.extradata_size);
st->codec->extradata_size= codec_data_size - (url_ftell(pb) - codec_pos);
st->codec->extradata= av_malloc(st->codec->extradata_size);
get_buffer(pb, st->codec->extradata, st->codec->extradata_size);
// av_log(NULL, AV_LOG_DEBUG, "fps= %d fps2= %d\n", fps, fps2);
st->codec.time_base.den = fps * st->codec.time_base.num;
st->codec->time_base.den = fps * st->codec->time_base.num;
/* modification of h263 codec version (!) */
#ifdef WORDS_BIGENDIAN
h263_hack_version = ((uint32_t*)st->codec.extradata)[1];
h263_hack_version = ((uint32_t*)st->codec->extradata)[1];
#else
h263_hack_version = bswap_32(((uint32_t*)st->codec.extradata)[1]);
h263_hack_version = bswap_32(((uint32_t*)st->codec->extradata)[1]);
#endif
st->codec.sub_id = h263_hack_version;
st->codec->sub_id = h263_hack_version;
switch((h263_hack_version>>28)){
case 1: st->codec.codec_id = CODEC_ID_RV10; break;
case 2: st->codec.codec_id = CODEC_ID_RV20; break;
case 3: st->codec.codec_id = CODEC_ID_RV30; break;
case 4: st->codec.codec_id = CODEC_ID_RV40; break;
case 1: st->codec->codec_id = CODEC_ID_RV10; break;
case 2: st->codec->codec_id = CODEC_ID_RV20; break;
case 3: st->codec->codec_id = CODEC_ID_RV30; break;
case 4: st->codec->codec_id = CODEC_ID_RV40; break;
default: goto fail1;
}
}
@ -827,7 +827,7 @@ resync:
return AVERROR_IO;
st = s->streams[i];
if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
int h, pic_num, len2, pos;
h= get_byte(pb); len--;
@ -862,8 +862,8 @@ resync:
pkt->stream_index = i;
#if 0
if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
if(st->codec.codec_id == CODEC_ID_RV20){
if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
if(st->codec->codec_id == CODEC_ID_RV20){
int seq= 128*(pkt->data[2]&0x7F) + (pkt->data[3]>>1);
av_log(NULL, AV_LOG_DEBUG, "%d %Ld %d\n", timestamp, timestamp*512LL/25, seq);
@ -882,7 +882,7 @@ resync:
}
/* for AC3, needs to swap bytes */
if (st->codec.codec_id == CODEC_ID_AC3) {
if (st->codec->codec_id == CODEC_ID_AC3) {
ptr = pkt->data;
for(j=0;j<len;j+=2) {
tmp = ptr[0];
@ -937,7 +937,7 @@ static int64_t rm_read_dts(AVFormatContext *s, int stream_index,
return AV_NOPTS_VALUE;
st = s->streams[stream_index2];
if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
h= get_byte(&s->pb); len--;
if(!(h & 0x40)){
seq = get_byte(&s->pb); len--;

33
libavformat/rtp.c
View File

@ -290,7 +290,7 @@ RTPDemuxContext *rtp_parse_open(AVFormatContext *s1, AVStream *st, int payload_t
return NULL;
}
} else {
switch(st->codec.codec_id) {
switch(st->codec->codec_id) {
case CODEC_ID_MPEG1VIDEO:
case CODEC_ID_MPEG2VIDEO:
case CODEC_ID_MP2:
@ -307,7 +307,6 @@ RTPDemuxContext *rtp_parse_open(AVFormatContext *s1, AVStream *st, int payload_t
static int rtp_parse_mp4_au(RTPDemuxContext *s, const uint8_t *buf)
{
AVCodecContext codec;
int au_headers_length, au_header_size, i;
GetBitContext getbitcontext;
rtp_payload_data_t *infos;
@ -317,8 +316,6 @@ static int rtp_parse_mp4_au(RTPDemuxContext *s, const uint8_t *buf)
if (infos == NULL)
return -1;
codec = s->st->codec;
/* decode the first 2 bytes where are stored the AUHeader sections
length in bits */
au_headers_length = BE_16(buf);
@ -407,7 +404,7 @@ int rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt,
return -1;
#if defined(DEBUG) || 1
if (seq != ((s->seq + 1) & 0xffff)) {
av_log(&s->st->codec, AV_LOG_ERROR, "RTP: PT=%02x: bad cseq %04x expected=%04x\n",
av_log(s->st->codec, AV_LOG_ERROR, "RTP: PT=%02x: bad cseq %04x expected=%04x\n",
payload_type, seq, ((s->seq + 1) & 0xffff));
}
#endif
@ -428,7 +425,7 @@ int rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt,
return 1;
}
} else {
switch(st->codec.codec_id) {
switch(st->codec->codec_id) {
case CODEC_ID_MP2:
/* better than nothing: skip mpeg audio RTP header */
if (len <= 4)
@ -462,7 +459,7 @@ int rtp_parse_packet(RTPDemuxContext *s, AVPacket *pkt,
break;
}
switch(st->codec.codec_id) {
switch(st->codec->codec_id) {
case CODEC_ID_MP2:
case CODEC_ID_MPEG1VIDEO:
if (s->last_rtcp_ntp_time != AV_NOPTS_VALUE) {
@ -529,7 +526,7 @@ static int rtp_write_header(AVFormatContext *s1)
return -1;
st = s1->streams[0];
payload_type = rtp_get_payload_type(&st->codec);
payload_type = rtp_get_payload_type(st->codec);
if (payload_type < 0)
payload_type = RTP_PT_PRIVATE; /* private payload type */
s->payload_type = payload_type;
@ -544,7 +541,7 @@ static int rtp_write_header(AVFormatContext *s1)
return AVERROR_IO;
s->max_payload_size = max_packet_size - 12;
switch(st->codec.codec_id) {
switch(st->codec->codec_id) {
case CODEC_ID_MP2:
case CODEC_ID_MP3:
s->buf_ptr = s->buf + 4;
@ -663,7 +660,7 @@ static void rtp_send_mpegaudio(AVFormatContext *s1,
s->buf_ptr = s->buf + 4;
/* 90 KHz time stamp */
s->timestamp = s->base_timestamp +
(s->cur_timestamp * 90000LL) / st->codec.sample_rate;
(s->cur_timestamp * 90000LL) / st->codec->sample_rate;
}
}
@ -697,7 +694,7 @@ static void rtp_send_mpegaudio(AVFormatContext *s1,
memcpy(s->buf_ptr, buf1, size);
s->buf_ptr += size;
}
s->cur_timestamp += st->codec.frame_size;
s->cur_timestamp += st->codec->frame_size;
}
/* NOTE: a single frame must be passed with sequence header if
@ -715,7 +712,7 @@ static void rtp_send_mpegvideo(AVFormatContext *s1,
while (size > 0) {
/* XXX: more correct headers */
h = 0;
if (st->codec.sub_id == 2)
if (st->codec->sub_id == 2)
h |= 1 << 26; /* mpeg 2 indicator */
q = s->buf;
*q++ = h >> 24;
@ -723,7 +720,7 @@ static void rtp_send_mpegvideo(AVFormatContext *s1,
*q++ = h >> 8;
*q++ = h;
if (st->codec.sub_id == 2) {
if (st->codec->sub_id == 2) {
h = 0;
*q++ = h >> 24;
*q++ = h >> 16;
@ -740,7 +737,7 @@ static void rtp_send_mpegvideo(AVFormatContext *s1,
/* 90 KHz time stamp */
s->timestamp = s->base_timestamp +
av_rescale((int64_t)s->cur_timestamp * st->codec.time_base.num, 90000, st->codec.time_base.den); //FIXME pass timestamps
av_rescale((int64_t)s->cur_timestamp * st->codec->time_base.num, 90000, st->codec->time_base.den); //FIXME pass timestamps
rtp_send_data(s1, s->buf, q - s->buf);
buf1 += len;
@ -765,7 +762,7 @@ static void rtp_send_raw(AVFormatContext *s1,
/* 90 KHz time stamp */
s->timestamp = s->base_timestamp +
av_rescale((int64_t)s->cur_timestamp * st->codec.time_base.num, 90000, st->codec.time_base.den); //FIXME pass timestamps
av_rescale((int64_t)s->cur_timestamp * st->codec->time_base.num, 90000, st->codec->time_base.den); //FIXME pass timestamps
rtp_send_data(s1, buf1, len);
buf1 += len;
@ -824,18 +821,18 @@ static int rtp_write_packet(AVFormatContext *s1, AVPacket *pkt)
s->first_packet = 0;
}
switch(st->codec.codec_id) {
switch(st->codec->codec_id) {
case CODEC_ID_PCM_MULAW:
case CODEC_ID_PCM_ALAW:
case CODEC_ID_PCM_U8:
case CODEC_ID_PCM_S8:
rtp_send_samples(s1, buf1, size, 1 * st->codec.channels);
rtp_send_samples(s1, buf1, size, 1 * st->codec->channels);
break;
case CODEC_ID_PCM_U16BE:
case CODEC_ID_PCM_U16LE:
case CODEC_ID_PCM_S16BE:
case CODEC_ID_PCM_S16LE:
rtp_send_samples(s1, buf1, size, 2 * st->codec.channels);
rtp_send_samples(s1, buf1, size, 2 * st->codec->channels);
break;
case CODEC_ID_MP2:
case CODEC_ID_MP3:

8
libavformat/rtsp.c
View File

@ -282,7 +282,7 @@ static void sdp_parse_fmtp(AVStream *st, const char *p)
int i;
RTSPStream *rtsp_st = st->priv_data;
AVCodecContext *codec = &st->codec;
AVCodecContext *codec = st->codec;
rtp_payload_data_t *rtp_payload_data = &rtsp_st->rtp_payload_data;
/* loop on each attribute */
@ -405,10 +405,10 @@ static void sdp_parse_line(AVFormatContext *s, SDPParseState *s1,
return;
st->priv_data = rtsp_st;
rtsp_st->stream_index = st->index;
st->codec.codec_type = codec_type;
st->codec->codec_type = codec_type;
if (rtsp_st->sdp_payload_type < RTP_PT_PRIVATE) {
/* if standard payload type, we can find the codec right now */
rtp_get_codec_info(&st->codec, rtsp_st->sdp_payload_type);
rtp_get_codec_info(st->codec, rtsp_st->sdp_payload_type);
}
}
/* put a default control url */
@ -438,7 +438,7 @@ static void sdp_parse_line(AVFormatContext *s, SDPParseState *s1,
st = s->streams[i];
rtsp_st = st->priv_data;
if (rtsp_st->sdp_payload_type == payload_type) {
sdp_parse_rtpmap(&st->codec, payload_type, p);
sdp_parse_rtpmap(st->codec, payload_type, p);
}
}
} else if (strstart(p, "fmtp:", &p)) {

30
libavformat/segafilm.c
View File

@ -140,11 +140,11 @@ static int film_read_header(AVFormatContext *s,
if (!st)
return AVERROR_NOMEM;
film->video_stream_index = st->index;
st->codec.codec_type = CODEC_TYPE_VIDEO;
st->codec.codec_id = film->video_type;
st->codec.codec_tag = 0; /* no fourcc */
st->codec.width = BE_32(&scratch[16]);
st->codec.height = BE_32(&scratch[12]);
st->codec->codec_type = CODEC_TYPE_VIDEO;
st->codec->codec_id = film->video_type;
st->codec->codec_tag = 0; /* no fourcc */
st->codec->width = BE_32(&scratch[16]);
st->codec->height = BE_32(&scratch[12]);
}
if (film->audio_type) {
@ -152,16 +152,16 @@ static int film_read_header(AVFormatContext *s,
if (!st)
return AVERROR_NOMEM;
film->audio_stream_index = st->index;
st->codec.codec_type = CODEC_TYPE_AUDIO;
st->codec.codec_id = film->audio_type;
st->codec.codec_tag = 1;
st->codec.channels = film->audio_channels;
st->codec.bits_per_sample = film->audio_bits;
st->codec.sample_rate = film->audio_samplerate;
st->codec.bit_rate = st->codec.channels * st->codec.sample_rate *
st->codec.bits_per_sample;
st->codec.block_align = st->codec.channels *
st->codec.bits_per_sample / 8;
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->codec_id = film->audio_type;
st->codec->codec_tag = 1;
st->codec->channels = film->audio_channels;
st->codec->bits_per_sample = film->audio_bits;
st->codec->sample_rate = film->audio_samplerate;
st->codec->bit_rate = st->codec->channels * st->codec->sample_rate *
st->codec->bits_per_sample;
st->codec->block_align = st->codec->channels *
st->codec->bits_per_sample / 8;
}
/* load the sample table */

50
libavformat/sierravmd.c
View File

@ -131,14 +131,14 @@ static int vmd_read_header(AVFormatContext *s,
return AVERROR_NOMEM;
av_set_pts_info(st, 33, 1, 90000);
vmd->video_stream_index = st->index;
st->codec.codec_type = CODEC_TYPE_VIDEO;
st->codec.codec_id = CODEC_ID_VMDVIDEO;
st->codec.codec_tag = 0; /* no fourcc */
st->codec.width = LE_16(&vmd->vmd_header[12]);
st->codec.height = LE_16(&vmd->vmd_header[14]);
st->codec.extradata_size = VMD_HEADER_SIZE;
st->codec.extradata = av_malloc(VMD_HEADER_SIZE);
memcpy(st->codec.extradata, vmd->vmd_header, VMD_HEADER_SIZE);
st->codec->codec_type = CODEC_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_VMDVIDEO;
st->codec->codec_tag = 0; /* no fourcc */
st->codec->width = LE_16(&vmd->vmd_header[12]);
st->codec->height = LE_16(&vmd->vmd_header[14]);
st->codec->extradata_size = VMD_HEADER_SIZE;
st->codec->extradata = av_malloc(VMD_HEADER_SIZE);
memcpy(st->codec->extradata, vmd->vmd_header, VMD_HEADER_SIZE);
/* if sample rate is 0, assume no audio */
vmd->sample_rate = LE_16(&vmd->vmd_header[804]);
@ -148,29 +148,29 @@ static int vmd_read_header(AVFormatContext *s,
return AVERROR_NOMEM;
av_set_pts_info(st, 33, 1, 90000);
vmd->audio_stream_index = st->index;
st->codec.codec_type = CODEC_TYPE_AUDIO;
st->codec.codec_id = CODEC_ID_VMDAUDIO;
st->codec.codec_tag = 0; /* no codec tag */
st->codec.channels = (vmd->vmd_header[811] & 0x80) ? 2 : 1;
st->codec.sample_rate = vmd->sample_rate;
st->codec.block_align = vmd->audio_block_align =
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->codec_id = CODEC_ID_VMDAUDIO;
st->codec->codec_tag = 0; /* no codec tag */
st->codec->channels = (vmd->vmd_header[811] & 0x80) ? 2 : 1;
st->codec->sample_rate = vmd->sample_rate;
st->codec->block_align = vmd->audio_block_align =
LE_16(&vmd->vmd_header[806]);
if (st->codec.block_align & 0x8000) {
st->codec.bits_per_sample = 16;
st->codec.block_align = -(st->codec.block_align - 0x10000);
if (st->codec->block_align & 0x8000) {
st->codec->bits_per_sample = 16;
st->codec->block_align = -(st->codec->block_align - 0x10000);
} else
st->codec.bits_per_sample = 16;
// st->codec.bits_per_sample = 8;
st->codec.bit_rate = st->codec.sample_rate *
st->codec.bits_per_sample * st->codec.channels;
st->codec->bits_per_sample = 16;
// st->codec->bits_per_sample = 8;
st->codec->bit_rate = st->codec->sample_rate *
st->codec->bits_per_sample * st->codec->channels;
/* for calculating pts */
vmd->audio_frame_divisor = st->codec.bits_per_sample / 8 /
st->codec.channels;
vmd->audio_frame_divisor = st->codec->bits_per_sample / 8 /
st->codec->channels;
video_pts_inc = 90000;
video_pts_inc *= st->codec.block_align;
video_pts_inc /= st->codec.sample_rate;
video_pts_inc *= st->codec->block_align;
video_pts_inc /= st->codec->sample_rate;
} else {
/* if no audio, assume 10 frames/second */
video_pts_inc = 90000 / 10;

10
libavformat/sol.c
View File

@ -113,11 +113,11 @@ static int sol_read_header(AVFormatContext *s,
st = av_new_stream(s, 0);
if (!st)
return -1;
st->codec.codec_type = CODEC_TYPE_AUDIO;
st->codec.codec_tag = id;
st->codec.codec_id = codec;
st->codec.channels = channels;
st->codec.sample_rate = rate;
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->codec_tag = id;
st->codec->codec_id = codec;
st->codec->channels = channels;
st->codec->sample_rate = rate;
av_set_pts_info(st, 64, 1, rate);
return 0;
}

32
libavformat/swf.c
View File

@ -324,7 +324,7 @@ static int swf_write_header(AVFormatContext *s)
video_enc = NULL;
audio_enc = NULL;
for(i=0;i<s->nb_streams;i++) {
enc = &s->streams[i]->codec;
enc = s->streams[i]->codec;
if (enc->codec_type == CODEC_TYPE_AUDIO)
audio_enc = enc;
else {
@ -652,7 +652,7 @@ static int swf_write_audio(AVFormatContext *s,
static int swf_write_packet(AVFormatContext *s, AVPacket *pkt)
{
AVCodecContext *codec = &s->streams[pkt->stream_index]->codec;
AVCodecContext *codec = s->streams[pkt->stream_index]->codec;
if (codec->codec_type == CODEC_TYPE_AUDIO)
return swf_write_audio(s, codec, pkt->data, pkt->size);
else
@ -668,7 +668,7 @@ static int swf_write_trailer(AVFormatContext *s)
video_enc = NULL;
for(i=0;i<s->nb_streams;i++) {
enc = &s->streams[i]->codec;
enc = s->streams[i]->codec;
if (enc->codec_type == CODEC_TYPE_VIDEO)
video_enc = enc;
}
@ -775,8 +775,8 @@ static int swf_read_header(AVFormatContext *s, AVFormatParameters *ap)
if (tag < 0) {
if ( ast || vst ) {
if ( vst && ast ) {
vst->codec.time_base.den = ast->codec.sample_rate / swf->samples_per_frame;
vst->codec.time_base.num = 1;
vst->codec->time_base.den = ast->codec->sample_rate / swf->samples_per_frame;
vst->codec->time_base.num = 1;
}
break;
}
@ -794,11 +794,11 @@ static int swf_read_header(AVFormatContext *s, AVFormatParameters *ap)
vst = av_new_stream(s, 0);
av_set_pts_info(vst, 24, 1, 1000); /* 24 bit pts in ms */
vst->codec.codec_type = CODEC_TYPE_VIDEO;
vst->codec.codec_id = CODEC_ID_FLV1;
vst->codec->codec_type = CODEC_TYPE_VIDEO;
vst->codec->codec_id = CODEC_ID_FLV1;
if ( swf->samples_per_frame ) {
vst->codec.time_base.den = 1000. / swf->ms_per_frame;
vst->codec.time_base.num = 1;
vst->codec->time_base.den = 1000. / swf->ms_per_frame;
vst->codec->time_base.num = 1;
}
}
} else if ( ( tag == TAG_STREAMHEAD || tag == TAG_STREAMHEAD2 ) && !ast) {
@ -819,26 +819,26 @@ static int swf_read_header(AVFormatContext *s, AVFormatParameters *ap)
return -ENOMEM;
if (v & 0x01)
ast->codec.channels = 2;
ast->codec->channels = 2;
else
ast->codec.channels = 1;
ast->codec->channels = 1;
switch((v>> 2) & 0x03) {
case 1:
ast->codec.sample_rate = 11025;
ast->codec->sample_rate = 11025;
break;
case 2:
ast->codec.sample_rate = 22050;
ast->codec->sample_rate = 22050;
break;
case 3:
ast->codec.sample_rate = 44100;
ast->codec->sample_rate = 44100;
break;
default:
av_free(ast);
return AVERROR_IO;
}
ast->codec.codec_type = CODEC_TYPE_AUDIO;
ast->codec.codec_id = CODEC_ID_MP3;
ast->codec->codec_type = CODEC_TYPE_AUDIO;
ast->codec->codec_id = CODEC_ID_MP3;
}
} else {
url_fskip(pb, len);

154
libavformat/utils.c
View File

@ -683,14 +683,14 @@ static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
*pnum = 0;
*pden = 0;
switch(st->codec.codec_type) {
switch(st->codec->codec_type) {
case CODEC_TYPE_VIDEO:
if(st->time_base.num*1000LL > st->time_base.den){
*pnum = st->time_base.num;
*pden = st->time_base.den;
}else if(st->codec.time_base.num*1000LL > st->codec.time_base.den){
*pnum = st->codec.time_base.num;
*pden = st->codec.time_base.den;
}else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
*pnum = st->codec->time_base.num;
*pden = st->codec->time_base.den;
if (pc && pc->repeat_pict) {
*pden *= 2;
*pnum = (*pnum) * (2 + pc->repeat_pict);
@ -698,11 +698,11 @@ static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
}
break;
case CODEC_TYPE_AUDIO:
frame_size = get_audio_frame_size(&st->codec, pkt->size);
frame_size = get_audio_frame_size(st->codec, pkt->size);
if (frame_size < 0)
break;
*pnum = frame_size;
*pden = st->codec.sample_rate;
*pden = st->codec->sample_rate;
break;
default:
break;
@ -756,16 +756,16 @@ static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
}
}
if(is_intra_only(&st->codec))
if(is_intra_only(st->codec))
pkt->flags |= PKT_FLAG_KEY;
/* do we have a video B frame ? */
presentation_delayed = 0;
if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
/* XXX: need has_b_frame, but cannot get it if the codec is
not initialized */
if (( st->codec.codec_id == CODEC_ID_H264
|| st->codec.has_b_frames) &&
if (( st->codec->codec_id == CODEC_ID_H264
|| st->codec->has_b_frames) &&
pc && pc->pict_type != FF_B_TYPE)
presentation_delayed = 1;
/* this may be redundant, but it shouldnt hurt */
@ -834,7 +834,7 @@ static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
if (pc) {
pkt->flags = 0;
/* key frame computation */
switch(st->codec.codec_type) {
switch(st->codec->codec_type) {
case CODEC_TYPE_VIDEO:
if (pc->pict_type == FF_I_TYPE)
pkt->flags |= PKT_FLAG_KEY;
@ -870,7 +870,7 @@ static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
s->cur_st = NULL;
return 0;
} else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
len = av_parser_parse(st->parser, &st->codec, &pkt->data, &pkt->size,
len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
s->cur_ptr, s->cur_len,
s->cur_pkt.pts, s->cur_pkt.dts);
s->cur_pkt.pts = AV_NOPTS_VALUE;
@ -905,7 +905,7 @@ static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
for(i = 0; i < s->nb_streams; i++) {
st = s->streams[i];
if (st->parser && st->need_parsing) {
av_parser_parse(st->parser, &st->codec,
av_parser_parse(st->parser, st->codec,
&pkt->data, &pkt->size,
NULL, 0,
AV_NOPTS_VALUE, AV_NOPTS_VALUE);
@ -923,7 +923,7 @@ static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
s->cur_ptr = s->cur_pkt.data;
s->cur_len = s->cur_pkt.size;
if (st->need_parsing && !st->parser) {
st->parser = av_parser_init(st->codec.codec_id);
st->parser = av_parser_init(st->codec->codec_id);
if (!st->parser) {
/* no parser available : just output the raw packets */
st->need_parsing = 0;
@ -995,7 +995,7 @@ int av_find_default_stream_index(AVFormatContext *s)
return -1;
for(i = 0; i < s->nb_streams; i++) {
st = s->streams[i];
if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
return i;
}
}
@ -1537,7 +1537,7 @@ static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
bit_rate = 0;
for(i=0;i<ic->nb_streams;i++) {
st = ic->streams[i];
bit_rate += st->codec.bit_rate;
bit_rate += st->codec->bit_rate;
}
ic->bit_rate = bit_rate;
}
@ -1728,26 +1728,26 @@ static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
int got_picture, ret=0;
AVFrame picture;
if(!st->codec.codec){
codec = avcodec_find_decoder(st->codec.codec_id);
if(!st->codec->codec){
codec = avcodec_find_decoder(st->codec->codec_id);
if (!codec)
return -1;
ret = avcodec_open(&st->codec, codec);
ret = avcodec_open(st->codec, codec);
if (ret < 0)
return ret;
}
if(!has_codec_parameters(&st->codec)){
switch(st->codec.codec_type) {
if(!has_codec_parameters(st->codec)){
switch(st->codec->codec_type) {
case CODEC_TYPE_VIDEO:
ret = avcodec_decode_video(&st->codec, &picture,
ret = avcodec_decode_video(st->codec, &picture,
&got_picture, (uint8_t *)data, size);
break;
case CODEC_TYPE_AUDIO:
samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
if (!samples)
goto fail;
ret = avcodec_decode_audio(&st->codec, samples,
ret = avcodec_decode_audio(st->codec, samples,
&got_picture, (uint8_t *)data, size);
av_free(samples);
break;
@ -1787,15 +1787,15 @@ int av_find_stream_info(AVFormatContext *ic)
for(i=0;i<ic->nb_streams;i++) {
st = ic->streams[i];
if(st->codec.codec_type == CODEC_TYPE_VIDEO){
if(st->codec->codec_type == CODEC_TYPE_VIDEO){
/* if(!st->time_base.num)
st->time_base= */
if(!st->codec.time_base.num)
st->codec.time_base= st->time_base;
if(!st->codec->time_base.num)
st->codec->time_base= st->time_base;
}
//only for the split stuff
if (!st->parser) {
st->parser = av_parser_init(st->codec.codec_id);
st->parser = av_parser_init(st->codec->codec_id);
}
}
@ -1811,13 +1811,13 @@ int av_find_stream_info(AVFormatContext *ic)
/* check if one codec still needs to be handled */
for(i=0;i<ic->nb_streams;i++) {
st = ic->streams[i];
if (!has_codec_parameters(&st->codec))
if (!has_codec_parameters(st->codec))
break;
/* variable fps and no guess at the real fps */
if( st->codec.time_base.den >= 1000LL*st->codec.time_base.num
&& duration_count[i]<20 && st->codec.codec_type == CODEC_TYPE_VIDEO)
if( st->codec->time_base.den >= 1000LL*st->codec->time_base.num
&& duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
break;
if(st->parser && st->parser->parser->split && !st->codec.extradata)
if(st->parser && st->parser->parser->split && !st->codec->extradata)
break;
}
if (i == ic->nb_streams) {
@ -1845,7 +1845,7 @@ int av_find_stream_info(AVFormatContext *ic)
ret = -1; /* we could not have all the codec parameters before EOF */
for(i=0;i<ic->nb_streams;i++) {
st = ic->streams[i];
if (!has_codec_parameters(&st->codec))
if (!has_codec_parameters(st->codec))
break;
}
if (i == ic->nb_streams)
@ -1898,12 +1898,12 @@ int av_find_stream_info(AVFormatContext *ic)
}
last_dts[pkt->stream_index]= pkt->dts;
}
if(st->parser && st->parser->parser->split && !st->codec.extradata){
int i= st->parser->parser->split(&st->codec, pkt->data, pkt->size);
if(st->parser && st->parser->parser->split && !st->codec->extradata){
int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
if(i){
st->codec.extradata_size= i;
st->codec.extradata= av_malloc(st->codec.extradata_size);
memcpy(st->codec.extradata, pkt->data, st->codec.extradata_size);
st->codec->extradata_size= i;
st->codec->extradata= av_malloc(st->codec->extradata_size);
memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
}
}
@ -1911,21 +1911,21 @@ int av_find_stream_info(AVFormatContext *ic)
decompress the frame. We try to avoid that in most cases as
it takes longer and uses more memory. For MPEG4, we need to
decompress for Quicktime. */
if (!has_codec_parameters(&st->codec) /*&&
(st->codec.codec_id == CODEC_ID_FLV1 ||
st->codec.codec_id == CODEC_ID_H264 ||
st->codec.codec_id == CODEC_ID_H263 ||
st->codec.codec_id == CODEC_ID_H261 ||
st->codec.codec_id == CODEC_ID_VORBIS ||
st->codec.codec_id == CODEC_ID_MJPEG ||
st->codec.codec_id == CODEC_ID_PNG ||
st->codec.codec_id == CODEC_ID_PAM ||
st->codec.codec_id == CODEC_ID_PGM ||
st->codec.codec_id == CODEC_ID_PGMYUV ||
st->codec.codec_id == CODEC_ID_PBM ||
st->codec.codec_id == CODEC_ID_PPM ||
st->codec.codec_id == CODEC_ID_SHORTEN ||
(st->codec.codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
if (!has_codec_parameters(st->codec) /*&&
(st->codec->codec_id == CODEC_ID_FLV1 ||
st->codec->codec_id == CODEC_ID_H264 ||
st->codec->codec_id == CODEC_ID_H263 ||
st->codec->codec_id == CODEC_ID_H261 ||
st->codec->codec_id == CODEC_ID_VORBIS ||
st->codec->codec_id == CODEC_ID_MJPEG ||
st->codec->codec_id == CODEC_ID_PNG ||
st->codec->codec_id == CODEC_ID_PAM ||
st->codec->codec_id == CODEC_ID_PGM ||
st->codec->codec_id == CODEC_ID_PGMYUV ||
st->codec->codec_id == CODEC_ID_PBM ||
st->codec->codec_id == CODEC_ID_PPM ||
st->codec->codec_id == CODEC_ID_SHORTEN ||
(st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
try_decode_frame(st, pkt->data, pkt->size);
if (av_rescale_q(st->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= MAX_STREAM_DURATION) {
@ -1937,16 +1937,16 @@ int av_find_stream_info(AVFormatContext *ic)
// close codecs which where opened in try_decode_frame()
for(i=0;i<ic->nb_streams;i++) {
st = ic->streams[i];
if(st->codec.codec)
avcodec_close(&st->codec);
if(st->codec->codec)
avcodec_close(st->codec);
}
for(i=0;i<ic->nb_streams;i++) {
st = ic->streams[i];
if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
if(st->codec.codec_id == CODEC_ID_RAWVIDEO && !st->codec.codec_tag && !st->codec.bits_per_sample)
st->codec.codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec.pix_fmt);
if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
if(duration_count[i] && st->codec.time_base.num*1000LL <= st->codec.time_base.den &&
if(duration_count[i] && st->codec->time_base.num*1000LL <= st->codec->time_base.den &&
st->time_base.num*duration_sum[i]/duration_count[i]*1000LL > st->time_base.den){
AVRational fps1;
int64_t num, den;
@ -1964,14 +1964,14 @@ int av_find_stream_info(AVFormatContext *ic)
/* set real frame rate info */
/* compute the real frame rate for telecine */
if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
st->codec.codec_id == CODEC_ID_MPEG2VIDEO) &&
st->codec.sub_id == 2) {
if ((st->codec->codec_id == CODEC_ID_MPEG1VIDEO ||
st->codec->codec_id == CODEC_ID_MPEG2VIDEO) &&
st->codec->sub_id == 2) {
if (st->codec_info_nb_frames >= 20) {
float coded_frame_rate, est_frame_rate;
est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) /
(double)st->codec_info_duration ;
coded_frame_rate = 1.0/av_q2d(st->codec.time_base);
coded_frame_rate = 1.0/av_q2d(st->codec->time_base);
#if 0
printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n",
coded_frame_rate, est_frame_rate);
@ -1987,8 +1987,8 @@ int av_find_stream_info(AVFormatContext *ic)
}
/* if no real frame rate, use the codec one */
if (!st->r_frame_rate.num){
st->r_frame_rate.num = st->codec.time_base.den;
st->r_frame_rate.den = st->codec.time_base.num;
st->r_frame_rate.num = st->codec->time_base.den;
st->r_frame_rate.den = st->codec->time_base.num;
}
}
}
@ -1998,7 +1998,7 @@ int av_find_stream_info(AVFormatContext *ic)
/* correct DTS for b frame streams with no timestamps */
for(i=0;i<ic->nb_streams;i++) {
st = ic->streams[i];
if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
if(b-frames){
ppktl = &ic->packet_buffer;
while(ppkt1){
@ -2069,6 +2069,7 @@ void av_close_input_file(AVFormatContext *s)
av_parser_close(st->parser);
}
av_free(st->index_entries);
av_free(st->codec);
av_free(st);
}
flush_packet_queue(s);
@ -2103,10 +2104,11 @@ AVStream *av_new_stream(AVFormatContext *s, int id)
st = av_mallocz(sizeof(AVStream));
if (!st)
return NULL;
avcodec_get_context_defaults(&st->codec);
st->codec= avcodec_alloc_context();
if (s->iformat) {
/* no default bitrate if decoding */
st->codec.bit_rate = 0;
st->codec->bit_rate = 0;
}
st->index = s->nb_streams;
st->id = id;
@ -2164,14 +2166,14 @@ int av_write_header(AVFormatContext *s)
for(i=0;i<s->nb_streams;i++) {
st = s->streams[i];
switch (st->codec.codec_type) {
switch (st->codec->codec_type) {
case CODEC_TYPE_AUDIO:
av_frac_init(&st->pts, 0, 0,
(int64_t)st->time_base.num * st->codec.sample_rate);
(int64_t)st->time_base.num * st->codec->sample_rate);
break;
case CODEC_TYPE_VIDEO:
av_frac_init(&st->pts, 0, 0,
(int64_t)st->time_base.num * st->codec.time_base.den);
(int64_t)st->time_base.num * st->codec->time_base.den);
break;
default:
break;
@ -2182,7 +2184,7 @@ int av_write_header(AVFormatContext *s)
//FIXME merge with compute_pkt_fields
static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
int b_frames = FFMAX(st->codec.has_b_frames, st->codec.max_b_frames);
int b_frames = FFMAX(st->codec->has_b_frames, st->codec->max_b_frames);
int num, den, frame_size;
// av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts:%lld dts:%lld cur_dts:%lld b:%d size:%d st:%d\n", pkt->pts, pkt->dts, st->cur_dts, b_frames, pkt->size, pkt->stream_index);
@ -2234,9 +2236,9 @@ static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
st->pts.val= pkt->dts;
/* update pts */
switch (st->codec.codec_type) {
switch (st->codec->codec_type) {
case CODEC_TYPE_AUDIO:
frame_size = get_audio_frame_size(&st->codec, pkt->size);
frame_size = get_audio_frame_size(st->codec, pkt->size);
/* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
but it would be better if we had the real timestamps from the encoder */
@ -2245,7 +2247,7 @@ static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
}
break;
case CODEC_TYPE_VIDEO:
av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec.time_base.num);
av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
break;
default:
break;
@ -2380,7 +2382,7 @@ int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
AVStream *st= s->streams[ pkt->stream_index];
//FIXME/XXX/HACK drop zero sized packets
if(st->codec.codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
return 0;
//av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %Ld %Ld\n", pkt->size, pkt->dts, pkt->pts);
@ -2497,7 +2499,7 @@ void dump_format(AVFormatContext *ic,
}
for(i=0;i<ic->nb_streams;i++) {
AVStream *st = ic->streams[i];
avcodec_string(buf, sizeof(buf), &st->codec, is_output);
avcodec_string(buf, sizeof(buf), st->codec, is_output);
av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
/* the pid is an important information, so we display it */
/* XXX: add a generic system */

18
libavformat/wav.c
View File

@ -199,13 +199,13 @@ static int wav_write_header(AVFormatContext *s)
/* format header */
fmt = start_tag(pb, "fmt ");
if (put_wav_header(pb, &s->streams[0]->codec) < 0) {
if (put_wav_header(pb, s->streams[0]->codec) < 0) {
av_free(wav);
return -1;
}
end_tag(pb, fmt);
av_set_pts_info(s->streams[0], 64, 1, s->streams[0]->codec.sample_rate);
av_set_pts_info(s->streams[0], 64, 1, s->streams[0]->codec->sample_rate);
/* data header */
wav->data = start_tag(pb, "data");
@ -305,10 +305,10 @@ static int wav_read_header(AVFormatContext *s,
if (!st)
return AVERROR_NOMEM;
get_wav_header(pb, &st->codec, size);
get_wav_header(pb, st->codec, size);
st->need_parsing = 1;
av_set_pts_info(st, 64, 1, st->codec.sample_rate);
av_set_pts_info(st, 64, 1, st->codec->sample_rate);
size = find_tag(pb, MKTAG('d', 'a', 't', 'a'));
if (size < 0)
@ -329,10 +329,10 @@ static int wav_read_packet(AVFormatContext *s,
st = s->streams[0];
size = MAX_SIZE;
if (st->codec.block_align > 1) {
if (size < st->codec.block_align)
size = st->codec.block_align;
size = (size / st->codec.block_align) * st->codec.block_align;
if (st->codec->block_align > 1) {
if (size < st->codec->block_align)
size = st->codec->block_align;
size = (size / st->codec->block_align) * st->codec->block_align;
}
if (av_new_packet(pkt, size))
return AVERROR_IO;
@ -358,7 +358,7 @@ static int wav_read_seek(AVFormatContext *s,
AVStream *st;
st = s->streams[0];
switch(st->codec.codec_id) {
switch(st->codec->codec_id) {
case CODEC_ID_MP2:
case CODEC_ID_MP3:
case CODEC_ID_AC3:

30
libavformat/wc3movie.c
View File

@ -239,29 +239,29 @@ static int wc3_read_header(AVFormatContext *s,
return AVERROR_NOMEM;
av_set_pts_info(st, 33, 1, 90000);
wc3->video_stream_index = st->index;
st->codec.codec_type = CODEC_TYPE_VIDEO;
st->codec.codec_id = CODEC_ID_XAN_WC3;
st->codec.codec_tag = 0; /* no fourcc */
st->codec.width = wc3->width;
st->codec.height = wc3->height;
st->codec->codec_type = CODEC_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_XAN_WC3;
st->codec->codec_tag = 0; /* no fourcc */
st->codec->width = wc3->width;
st->codec->height = wc3->height;
/* palette considerations */
st->codec.palctrl = &wc3->palette_control;
st->codec->palctrl = &wc3->palette_control;
st = av_new_stream(s, 0);
if (!st)
return AVERROR_NOMEM;
av_set_pts_info(st, 33, 1, 90000);
wc3->audio_stream_index = st->index;
st->codec.codec_type = CODEC_TYPE_AUDIO;
st->codec.codec_id = CODEC_ID_PCM_S16LE;
st->codec.codec_tag = 1;
st->codec.channels = WC3_AUDIO_CHANNELS;
st->codec.bits_per_sample = WC3_AUDIO_BITS;
st->codec.sample_rate = WC3_SAMPLE_RATE;
st->codec.bit_rate = st->codec.channels * st->codec.sample_rate *
st->codec.bits_per_sample;
st->codec.block_align = WC3_AUDIO_BITS * WC3_AUDIO_CHANNELS;
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->codec_id = CODEC_ID_PCM_S16LE;
st->codec->codec_tag = 1;
st->codec->channels = WC3_AUDIO_CHANNELS;
st->codec->bits_per_sample = WC3_AUDIO_BITS;
st->codec->sample_rate = WC3_SAMPLE_RATE;
st->codec->bit_rate = st->codec->channels * st->codec->sample_rate *
st->codec->bits_per_sample;
st->codec->block_align = WC3_AUDIO_BITS * WC3_AUDIO_CHANNELS;
return 0;
}

62
libavformat/westwood.c
View File

@ -136,15 +136,15 @@ static int wsaud_read_header(AVFormatContext *s,
if (!st)
return AVERROR_NOMEM;
av_set_pts_info(st, 33, 1, wsaud->audio_samplerate);
st->codec.codec_type = CODEC_TYPE_AUDIO;
st->codec.codec_id = wsaud->audio_type;
st->codec.codec_tag = 0; /* no tag */
st->codec.channels = wsaud->audio_channels;
st->codec.sample_rate = wsaud->audio_samplerate;
st->codec.bits_per_sample = wsaud->audio_bits;
st->codec.bit_rate = st->codec.channels * st->codec.sample_rate *
st->codec.bits_per_sample / 4;
st->codec.block_align = st->codec.channels * st->codec.bits_per_sample;
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->codec_id = wsaud->audio_type;
st->codec->codec_tag = 0; /* no tag */
st->codec->channels = wsaud->audio_channels;
st->codec->sample_rate = wsaud->audio_samplerate;
st->codec->bits_per_sample = wsaud->audio_bits;
st->codec->bit_rate = st->codec->channels * st->codec->sample_rate *
st->codec->bits_per_sample / 4;
st->codec->block_align = st->codec->channels * st->codec->bits_per_sample;
wsaud->audio_stream_index = st->index;
wsaud->audio_frame_counter = 0;
@ -222,24 +222,24 @@ static int wsvqa_read_header(AVFormatContext *s,
return AVERROR_NOMEM;
av_set_pts_info(st, 33, 1, 90000);
wsvqa->video_stream_index = st->index;
st->codec.codec_type = CODEC_TYPE_VIDEO;
st->codec.codec_id = CODEC_ID_WS_VQA;
st->codec.codec_tag = 0; /* no fourcc */
st->codec->codec_type = CODEC_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_WS_VQA;
st->codec->codec_tag = 0; /* no fourcc */
/* skip to the start of the VQA header */
url_fseek(pb, 20, SEEK_SET);
/* the VQA header needs to go to the decoder */
st->codec.extradata_size = VQA_HEADER_SIZE;
st->codec.extradata = av_malloc(VQA_HEADER_SIZE);
header = (unsigned char *)st->codec.extradata;
if (get_buffer(pb, st->codec.extradata, VQA_HEADER_SIZE) !=
st->codec->extradata_size = VQA_HEADER_SIZE;
st->codec->extradata = av_malloc(VQA_HEADER_SIZE);
header = (unsigned char *)st->codec->extradata;
if (get_buffer(pb, st->codec->extradata, VQA_HEADER_SIZE) !=
VQA_HEADER_SIZE) {
av_free(st->codec.extradata);
av_free(st->codec->extradata);
return AVERROR_IO;
}
st->codec.width = LE_16(&header[6]);
st->codec.height = LE_16(&header[8]);
st->codec->width = LE_16(&header[6]);
st->codec->height = LE_16(&header[8]);
/* initialize the audio decoder stream is sample rate is non-zero */
if (LE_16(&header[24])) {
@ -247,19 +247,19 @@ static int wsvqa_read_header(AVFormatContext *s,
if (!st)
return AVERROR_NOMEM;
av_set_pts_info(st, 33, 1, 90000);
st->codec.codec_type = CODEC_TYPE_AUDIO;
st->codec.codec_id = CODEC_ID_ADPCM_IMA_WS;
st->codec.codec_tag = 0; /* no tag */
st->codec.sample_rate = LE_16(&header[24]);
st->codec.channels = header[26];
st->codec.bits_per_sample = 16;
st->codec.bit_rate = st->codec.channels * st->codec.sample_rate *
st->codec.bits_per_sample / 4;
st->codec.block_align = st->codec.channels * st->codec.bits_per_sample;
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->codec_id = CODEC_ID_ADPCM_IMA_WS;
st->codec->codec_tag = 0; /* no tag */
st->codec->sample_rate = LE_16(&header[24]);
st->codec->channels = header[26];
st->codec->bits_per_sample = 16;
st->codec->bit_rate = st->codec->channels * st->codec->sample_rate *
st->codec->bits_per_sample / 4;
st->codec->block_align = st->codec->channels * st->codec->bits_per_sample;
wsvqa->audio_stream_index = st->index;
wsvqa->audio_samplerate = st->codec.sample_rate;
wsvqa->audio_channels = st->codec.channels;
wsvqa->audio_samplerate = st->codec->sample_rate;
wsvqa->audio_channels = st->codec->channels;
wsvqa->audio_frame_counter = 0;
}
@ -267,7 +267,7 @@ static int wsvqa_read_header(AVFormatContext *s,
* FINF has been skipped and the file will be ready to be demuxed */
do {
if (get_buffer(pb, scratch, VQA_PREAMBLE_SIZE) != VQA_PREAMBLE_SIZE) {
av_free(st->codec.extradata);
av_free(st->codec->extradata);
return AVERROR_IO;
}
chunk_tag = BE_32(&scratch[0]);

54
libavformat/yuv4mpeg.c
View File

@ -33,22 +33,22 @@ static int yuv4_generate_header(AVFormatContext *s, char* buf)
char *colorspace = "";
st = s->streams[0];
width = st->codec.width;
height = st->codec.height;
width = st->codec->width;
height = st->codec->height;
av_reduce(&raten, &rated, st->codec.time_base.den, st->codec.time_base.num, (1UL<<31)-1);
av_reduce(&raten, &rated, st->codec->time_base.den, st->codec->time_base.num, (1UL<<31)-1);
aspectn = st->codec.sample_aspect_ratio.num;
aspectd = st->codec.sample_aspect_ratio.den;
aspectn = st->codec->sample_aspect_ratio.num;
aspectd = st->codec->sample_aspect_ratio.den;
if ( aspectn == 0 && aspectd == 1 ) aspectd = 0; // 0:0 means unknown
inter = 'p'; /* progressive is the default */
if (st->codec.coded_frame && st->codec.coded_frame->interlaced_frame) {
inter = st->codec.coded_frame->top_field_first ? 't' : 'b';
if (st->codec->coded_frame && st->codec->coded_frame->interlaced_frame) {
inter = st->codec->coded_frame->top_field_first ? 't' : 'b';
}
switch(st->codec.pix_fmt) {
switch(st->codec->pix_fmt) {
case PIX_FMT_GRAY8:
colorspace = " Cmono";
break;
@ -56,7 +56,7 @@ static int yuv4_generate_header(AVFormatContext *s, char* buf)
colorspace = " C411 XYSCSS=411";
break;
case PIX_FMT_YUV420P:
colorspace = (st->codec.codec_id == CODEC_ID_DVVIDEO)?" C420paldv XYSCSS=420PALDV":" C420mpeg2 XYSCSS=420MPEG2";
colorspace = (st->codec->codec_id == CODEC_ID_DVVIDEO)?" C420paldv XYSCSS=420PALDV":" C420mpeg2 XYSCSS=420MPEG2";
break;
case PIX_FMT_YUV422P:
colorspace = " C422 XYSCSS=422";
@ -109,8 +109,8 @@ static int yuv4_write_packet(AVFormatContext *s, AVPacket *pkt)
m = snprintf(buf1, sizeof(buf1), "%s\n", Y4M_FRAME_MAGIC);
put_buffer(pb, buf1, strlen(buf1));
width = st->codec.width;
height = st->codec.height;
width = st->codec->width;
height = st->codec->height;
ptr = picture->data[0];
for(i=0;i<height;i++) {
@ -118,9 +118,9 @@ static int yuv4_write_packet(AVFormatContext *s, AVPacket *pkt)
ptr += picture->linesize[0];
}
if (st->codec.pix_fmt != PIX_FMT_GRAY8){
if (st->codec->pix_fmt != PIX_FMT_GRAY8){
// Adjust for smaller Cb and Cr planes
avcodec_get_chroma_sub_sample(st->codec.pix_fmt, &h_chroma_shift, &v_chroma_shift);
avcodec_get_chroma_sub_sample(st->codec->pix_fmt, &h_chroma_shift, &v_chroma_shift);
width >>= h_chroma_shift;
height >>= v_chroma_shift;
@ -146,13 +146,13 @@ static int yuv4_write_header(AVFormatContext *s)
if (s->nb_streams != 1)
return AVERROR_IO;
if (s->streams[0]->codec.pix_fmt == PIX_FMT_YUV411P) {
if (s->streams[0]->codec->pix_fmt == PIX_FMT_YUV411P) {
av_log(s, AV_LOG_ERROR, "Warning: generating rarely used 4:1:1 YUV stream, some mjpegtools might not work.\n");
}
else if ((s->streams[0]->codec.pix_fmt != PIX_FMT_YUV420P) &&
(s->streams[0]->codec.pix_fmt != PIX_FMT_YUV422P) &&
(s->streams[0]->codec.pix_fmt != PIX_FMT_GRAY8) &&
(s->streams[0]->codec.pix_fmt != PIX_FMT_YUV444P)) {
else if ((s->streams[0]->codec->pix_fmt != PIX_FMT_YUV420P) &&
(s->streams[0]->codec->pix_fmt != PIX_FMT_YUV422P) &&
(s->streams[0]->codec->pix_fmt != PIX_FMT_GRAY8) &&
(s->streams[0]->codec->pix_fmt != PIX_FMT_YUV444P)) {
av_log(s, AV_LOG_ERROR, "ERROR: yuv4mpeg only handles yuv444p, yuv422p, yuv420p, yuv411p and gray pixel formats. Use -pix_fmt to select one.\n");
return AVERROR_IO;
}
@ -320,14 +320,14 @@ static int yuv4_read_header(AVFormatContext *s, AVFormatParameters *ap)
st = av_new_stream(s, 0);
st = s->streams[0];
st->codec.width = width;
st->codec.height = height;
st->codec->width = width;
st->codec->height = height;
av_reduce(&raten, &rated, raten, rated, (1UL<<31)-1);
av_set_pts_info(st, 64, rated, raten);
st->codec.pix_fmt = pix_fmt;
st->codec.codec_type = CODEC_TYPE_VIDEO;
st->codec.codec_id = CODEC_ID_RAWVIDEO;
st->codec.sample_aspect_ratio= (AVRational){aspectn, aspectd};
st->codec->pix_fmt = pix_fmt;
st->codec->codec_type = CODEC_TYPE_VIDEO;
st->codec->codec_id = CODEC_ID_RAWVIDEO;
st->codec->sample_aspect_ratio= (AVRational){aspectn, aspectd};
return 0;
}
@ -349,10 +349,10 @@ static int yuv4_read_packet(AVFormatContext *s, AVPacket *pkt)
if (i == MAX_FRAME_HEADER) return -1;
if (strncmp(header, Y4M_FRAME_MAGIC, strlen(Y4M_FRAME_MAGIC))) return -1;
width = st->codec.width;
height = st->codec.height;
width = st->codec->width;
height = st->codec->height;
packet_size = avpicture_get_size(st->codec.pix_fmt, width, height);
packet_size = avpicture_get_size(st->codec->pix_fmt, width, height);
if (packet_size < 0)
return -1;

18
output_example.c
View File

@ -62,7 +62,7 @@ AVStream *add_audio_stream(AVFormatContext *oc, int codec_id)
exit(1);
}
c = &st->codec;
c = st->codec;
c->codec_id = codec_id;
c->codec_type = CODEC_TYPE_AUDIO;
@ -78,7 +78,7 @@ void open_audio(AVFormatContext *oc, AVStream *st)
AVCodecContext *c;
AVCodec *codec;
c = &st->codec;
c = st->codec;
/* find the audio encoder */
codec = avcodec_find_encoder(c->codec_id);
@ -106,7 +106,7 @@ void open_audio(AVFormatContext *oc, AVStream *st)
support to compute the input frame size in samples */
if (c->frame_size <= 1) {
audio_input_frame_size = audio_outbuf_size / c->channels;
switch(st->codec.codec_id) {
switch(st->codec->codec_id) {
case CODEC_ID_PCM_S16LE:
case CODEC_ID_PCM_S16BE:
case CODEC_ID_PCM_U16LE:
@ -145,7 +145,7 @@ void write_audio_frame(AVFormatContext *oc, AVStream *st)
AVPacket pkt;
av_init_packet(&pkt);
c = &st->codec;
c = st->codec;
get_audio_frame(samples, audio_input_frame_size, c->channels);
@ -165,7 +165,7 @@ void write_audio_frame(AVFormatContext *oc, AVStream *st)
void close_audio(AVFormatContext *oc, AVStream *st)
{
avcodec_close(&st->codec);
avcodec_close(st->codec);
av_free(samples);
av_free(audio_outbuf);
@ -190,7 +190,7 @@ AVStream *add_video_stream(AVFormatContext *oc, int codec_id)
exit(1);
}
c = &st->codec;
c = st->codec;
c->codec_id = codec_id;
c->codec_type = CODEC_TYPE_VIDEO;
@ -246,7 +246,7 @@ void open_video(AVFormatContext *oc, AVStream *st)
AVCodec *codec;
AVCodecContext *c;
c = &st->codec;
c = st->codec;
/* find the video encoder */
codec = avcodec_find_encoder(c->codec_id);
@ -317,7 +317,7 @@ void write_video_frame(AVFormatContext *oc, AVStream *st)
int out_size, ret;
AVCodecContext *c;
c = &st->codec;
c = st->codec;
if (frame_count >= STREAM_NB_FRAMES) {
/* no more frame to compress. The codec has a latency of a few
@ -379,7 +379,7 @@ void write_video_frame(AVFormatContext *oc, AVStream *st)
void close_video(AVFormatContext *oc, AVStream *st)
{
avcodec_close(&st->codec);
avcodec_close(st->codec);
av_free(picture->data[0]);
av_free(picture);
if (tmp_picture) {