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)
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){
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;
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) {
return;
}
- enc = &ost->st->codec;
+ enc = ost->st->codec;
if (!subtitle_out) {
subtitle_out = av_malloc(subtitle_out_max_size);
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;
}
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);
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);
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;
}
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)
/* 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;
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;
}
}
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;
}
/* 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);
/* 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;
//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;
/* 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++;
}
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);
}
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) {
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;
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;
}
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);
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;
/* 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;
}
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 */
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,
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;
}
}
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;
}
}
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;
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;
}
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){
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);
}
}
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);
}
}
/* 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);
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;
}
#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;
}
#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)
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;
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)
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;
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 */
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;
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;
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;
#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:
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;
/* 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;
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);
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) {
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);
{
int size, len, channels;
- channels = is->audio_st->codec.channels;
+ channels = is->audio_st->codec->channels;
size = samples_size / sizeof(short);
while (size > 0) {
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 */
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;
/* 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);
/* 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;
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) {
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:
}
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)
}
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);
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:
/* 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);
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 ||
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:
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 = "...";
}
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 = "...";
}
break;
case CODEC_TYPE_DATA:
- video_bit_rate += st->codec.bit_rate;
+ video_bit_rate += st->codec->bit_rate;
break;
default:
av_abort();
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");
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;
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;
}
}
}
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;
}
}
}
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;
}
}
*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;
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);
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);
}
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;
}
/* 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) {
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");
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;
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) {
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++;
}
}
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;
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++;
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);
}
} 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)) {
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;
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)
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 */
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;
}
}
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;
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
{
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;
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)
{
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 */
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;
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);
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)
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);
|| (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:
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 {
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;
}
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);
}
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;
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;
}
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;
}
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;
}
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;
}
/* 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;
extern "C" {
#endif
-#define LIBAVFORMAT_BUILD 4628
+#define LIBAVFORMAT_BUILD 4629
#define LIBAVFORMAT_VERSION_INT FFMPEG_VERSION_INT
#define LIBAVFORMAT_VERSION FFMPEG_VERSION
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
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);
}
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 */
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 */
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
/* 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;
}
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;
//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;
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;
}
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)
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;
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) {
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 */
}
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);
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) {
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);
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;
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;
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;
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};
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;
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);
/* 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);
}
/* 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;
}
/* 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;
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)
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;
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;
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;
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);
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 */
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;
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);
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);
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;
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);
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);
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) {
/*
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))
}
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;
}
}
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
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;
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;
}
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
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;
}
}
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;
}
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;
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:
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) {
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) *
/* 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);
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;
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) {
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;
} 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;
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;
}
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;
}
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);
}
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) {
}
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;
}
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 */
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) {
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);
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;
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. */
}
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));
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;
}
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);
/* "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" */
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;
}
/* 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 */
#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;
}
}
}
// 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);
-
- 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);
+ 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);
} else
url_fskip(pb, atom.size);
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);
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",
(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 */
#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
#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) ||
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;
}
}
- 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");
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.
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;
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;
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
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:
;
}
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;
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;
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;
}
#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];
{
// 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
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");
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 );
}
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)){
{
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;
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 */
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++;
}
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
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;
/* 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;
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;
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:
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);
}
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;
}
}
}
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;
}
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;
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",
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;
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 */
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 */
*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;
}
}
*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) {
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;
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;
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
}
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;
}
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));
}
}
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
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;
{
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);
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);
}
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;
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);
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);
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);
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);
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;
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){
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;
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);
}
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))
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;
}
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 = {
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;
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;
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;
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;
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;
}
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;
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;
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;
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);
}
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;
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;
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
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) */
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) {
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 */
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);
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;
}
}
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--;
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);
}
/* 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];
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--;
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:
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;
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);
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
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)
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) {
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;
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;
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;
}
}
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
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;
*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;
/* 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;
/* 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;
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:
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 */
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 */
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)) {
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) {
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 */
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]);
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;
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;
}
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 {
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
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;
}
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;
}
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) {
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);
*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);
}
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;
}
}
- 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 */
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;
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;
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);
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;
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;
}
}
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;
}
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;
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);
}
}
/* 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) {
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)
}
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);
}
}
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) {
// 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;
/* 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);
}
/* 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;
}
}
}
/* 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){
av_parser_close(st->parser);
}
av_free(st->index_entries);
+ av_free(st->codec);
av_free(st);
}
flush_packet_queue(s);
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;
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;
//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);
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 */
}
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;
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);
}
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 */
/* 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");
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)
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;
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:
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;
}
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;
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])) {
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;
}
* 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]);
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;
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";
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++) {
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;
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;
}
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;
}
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;
exit(1);
}
- c = &st->codec;
+ c = st->codec;
c->codec_id = codec_id;
c->codec_type = CODEC_TYPE_AUDIO;
AVCodecContext *c;
AVCodec *codec;
- c = &st->codec;
+ c = st->codec;
/* find the audio encoder */
codec = avcodec_find_encoder(c->codec_id);
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:
AVPacket pkt;
av_init_packet(&pkt);
- c = &st->codec;
+ c = st->codec;
get_audio_frame(samples, audio_input_frame_size, c->channels);
void close_audio(AVFormatContext *oc, AVStream *st)
{
- avcodec_close(&st->codec);
+ avcodec_close(st->codec);
av_free(samples);
av_free(audio_outbuf);
exit(1);
}
- c = &st->codec;
+ c = st->codec;
c->codec_id = codec_id;
c->codec_type = CODEC_TYPE_VIDEO;
AVCodec *codec;
AVCodecContext *c;
- c = &st->codec;
+ c = st->codec;
/* find the video encoder */
codec = avcodec_find_encoder(c->codec_id);
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
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) {
OSDN Git Service
