void decode_packet(void)
{
if(read_unsigned_value(1)) {
uint8_t header_type = read_unsigned_value(7);
if(read_unsigned_value(8) != 'v' ||
read_unsigned_value(8) != 'o' ||
read_unsigned_value(8) != 'r' ||
read_unsigned_value(8) != 'b' ||
read_unsigned_value(8) != 'i' ||
read_unsigned_value(8) != 's') {
ERROR(ERROR_VORBIS, "Corrupted header signature.\n");
}
switch(header_type) {
case 0:
decode_identification_header();
break;
case 1:
decode_comment_header();
break;
case 2:
decode_setup_header();
break;
default:
ERROR(ERROR_VORBIS, "Illegal header type: %u.\n", header_type);
}
} else {
prefetch_packet(1);
decode_audio_packet();
}
}
static int handle_group_audio_packet(void *object, int groupnumber, int friendgroupnumber, void *peer_object,
const uint8_t *packet, uint16_t length)
{
if (!peer_object || !object || length <= sizeof(uint16_t)) {
return -1;
}
Group_Peer_AV *peer_av = peer_object;
Group_Audio_Packet *pk = calloc(1, sizeof(Group_Audio_Packet) + (length - sizeof(uint16_t)));
if (!pk) {
return -1;
}
uint16_t sequnum;
memcpy(&sequnum, packet, sizeof(sequnum));
pk->sequnum = ntohs(sequnum);
pk->length = length - sizeof(uint16_t);
memcpy(pk->data, packet + sizeof(uint16_t), length - sizeof(uint16_t));
if (queue(peer_av->buffer, pk) == -1) {
free(pk);
return -1;
}
while (decode_audio_packet(object, peer_av, groupnumber, friendgroupnumber) == 0);
return 0;
}
static void no_output_audio_decoding
(
AVCodecContext *ctx,
AVPacket *pkt,
AVFrame *picture
)
{
do
{
int dummy;
int consumed_bytes = decode_audio_packet( ctx, picture, &dummy, pkt );
if( consumed_bytes < 0 )
return;
if( pkt->data )
{
pkt->size -= consumed_bytes;
pkt->data += consumed_bytes;
}
} while( pkt->size > 0 );
}
int VideoLayer::decode_audio_packet() {
return decode_audio_packet(NULL);
}
void *VideoLayer::feed() {
int got_picture=0;
int len1=0 ;
int ret=0;
bool got_it=false;
double now = get_master_clock();
if(paused)
return rgba_picture->data[0];
/**
* follow user video loop
*/
if(mark_in!=NO_MARK && mark_out!=NO_MARK && seekable) {
if (now >= mark_out)
seek((int64_t)mark_in * AV_TIME_BASE);
}
// operate seek if was requested
if(to_seek>=0) {
seek(to_seek);
to_seek = -1;
}
got_it=false;
while (!got_it) {
if(packet_len<=0) {
/**
* Read one packet from the media and put it in pkt
*/
while(1) {
#ifdef DEBUG
func("av_read_frame ...");
#endif
ret = av_read_frame(avformat_context, &pkt);
#ifdef DEBUG
if(pkt.stream_index == video_index)
std::cout << "video read packet";
else if(pkt.stream_index == audio_index)
std::cout << "audio read packet";
std::cout << " pkt.data=" << pkt.data;
std::cout << " pkt.size=" << pkt.size;
std::cout << " pkt.pts/dts=" << pkt.pts << "/" << pkt.dts << std::endl;
std::cout << "pkt.duration=" << pkt.duration;
std::cout << " avformat_context->start_time=" << avformat_context->start_time;
std::cout << " avformat_context->duration=" << avformat_context->duration/AV_TIME_BASE << std::endl;
std::cout << "avformat_context->duration=" << avformat_context->duration << std::endl;
#endif
/* TODO(shammash): this may be good for streams but breaks
* looping in files, needs fixing. */
// if(!pkt.duration) continue;
// if(!pkt.size || !pkt.data) {
// return NULL;
// }
/**
* check eof and loop
*/
if(ret!= 0) { //does not enter if data are available
eos->notify();
// eos->dispatcher->do_jobs(); /// XXX hack hack hack
ret = seek(avformat_context->start_time);
if (ret < 0) {
error("VideoLayer::could not loop file");
return rgba_picture->data[0];
}
continue;
} else if( (pkt.stream_index == video_index)
|| (pkt.stream_index == audio_index) )
break; /* exit loop */
}
} // loop break after a known index is found
frame_number++;
//std::cout << "frame_number :" << frame_number << std::endl;
/**
* Decode video
*/
if(pkt.stream_index == video_index) {
len1 = decode_video_packet(&got_picture);
AVFrame *yuv_picture=&av_frame;
if(len1<0) {
// error("VideoLayer::Error while decoding frame");
func("one frame only?");
return NULL;
}
else if (len1 == 0) {
packet_len=0;
return NULL;
}
/**
* We've found a picture
*/
ptr += len1;
packet_len -= len1;
if (got_picture!=0) {
got_it=true;
avformat_stream=avformat_context->streams[video_index];
/** Deinterlace input if requested */
if(deinterlaced)
deinterlace((AVPicture *)yuv_picture);
#ifdef WITH_SWSCALE
sws_scale(img_convert_ctx, yuv_picture->data, yuv_picture->linesize,
0, video_codec_ctx->height,
rgba_picture->data, rgba_picture->linesize);
#else
/**
* yuv2rgb
*/
img_convert(rgba_picture, PIX_FMT_RGB32, (AVPicture *)yuv_picture,
video_codec_ctx->pix_fmt,
//avformat_stream.codec->pix_fmt,
video_codec_ctx->width,
video_codec_ctx->height);
#endif
// memcpy(frame_fifo.picture[fifo_position % FIFO_SIZE]->data[0],rgba_picture->data[0],geo.size);
/* TODO move */
if(fifo_position == FIFO_SIZE)
fifo_position=0;
/* workaround since sws_scale conversion from YUV
returns an buffer RGBA with alpha set to 0x0 */
{
register int bufsize = ( rgba_picture->linesize[0] * video_codec_ctx->height ) /4;
int32_t *pbuf = (int32_t*)rgba_picture->data[0];
for(; bufsize>0; bufsize--) {
*pbuf = (*pbuf | alpha_bitmask);
pbuf++;
}
}
jmemcpy(frame_fifo.picture[fifo_position]->data[0],
rgba_picture->data[0],
rgba_picture->linesize[0] * video_codec_ctx->height);
// avpicture_get_size(PIX_FMT_RGBA32, enc->width, enc->height));
fifo_position++;
}
} // end video packet decoding
////////////////////////
// audio packet decoding
else if(pkt.stream_index == audio_index) {
// XXX(shammash): audio decoding seems to depend on screen properties, so
// we skip decoding audio frames if there's no screen
// long unsigned int m_SampleRate = screen->m_SampleRate?*(screen->m_SampleRate):48000;
// ringbuffer_write(screen->audio, (const char*)audio_float_buf, samples*sizeof(float));
// ... and so on ...
if(use_audio && screen) {
int data_size;
len1 = decode_audio_packet(&data_size);
if (len1 > 0) {
int samples = data_size/sizeof(uint16_t);
long unsigned int m_SampleRate = screen->m_SampleRate?*(screen->m_SampleRate):48000;
double m_ResampleRatio = (double)(m_SampleRate)/(double)audio_samplerate;
long unsigned max_buf = ceil(AVCODEC_MAX_AUDIO_FRAME_SIZE * m_ResampleRatio * audio_channels);
if (audio_resampled_buf_len < max_buf) {
if (audio_resampled_buf) free (audio_resampled_buf);
audio_resampled_buf = (float*) malloc(max_buf * sizeof(float));
audio_resampled_buf_len = max_buf;
}
src_short_to_float_array ((const short*) audio_buf, audio_float_buf, samples);
if (m_ResampleRatio == 1.0)
{
ringbuffer_write(screen->audio, (const char*)audio_float_buf, samples*sizeof(float));
time_t *tm = (time_t *)malloc(sizeof(time_t));
time (tm);
// std::cerr << "-- VL:" << asctime(localtime(tm));
}
else
{
src_short_to_float_array ((const short*) audio_buf, audio_float_buf, samples);
SRC_DATA src_data;
int offset = 0;
do {
src_data.input_frames = samples/audio_channels;
src_data.output_frames = audio_resampled_buf_len/audio_channels - offset;
src_data.end_of_input = 0;
src_data.src_ratio = m_ResampleRatio;
src_data.input_frames_used = 0;
src_data.output_frames_gen = 0;
src_data.data_in = audio_float_buf + offset;
src_data.data_out = audio_resampled_buf + offset;
src_simple (&src_data, SRC_SINC_MEDIUM_QUALITY, audio_channels) ;
ringbuffer_write(screen->audio,
(const char*)audio_resampled_buf,
src_data.output_frames_gen * audio_channels *sizeof(float));
offset += src_data.input_frames_used * audio_channels;
samples -= src_data.input_frames_used * audio_channels;
if (samples>0)
warning("resampling left: %i < %i",
src_data.input_frames_used, samples/audio_channels);
} while (samples > audio_channels);
}
}
}
}
av_free_packet(&pkt); /* sun's good. love's bad */
} // end of while(!got_it)
return frame_fifo.picture[fifo_position-1]->data[0];
}
