Attachment #71045 for bug #105597

View | Details | Raw Unified | Return to bug 105597
Collapse All | Expand All




    m_Streams.resize(m_pContext->nb_streams);
    for (int i = 0; i < m_pContext->nb_streams; i++)
    {
	AVCodecContext* avc = m_pContext->streams[i]->codec;
	AVM_WRITE("FF reader", "S: %d id:%x  bitrate:%d (%d) samprate:%d  chn:%d  wxh %dx%d  %d/%d\n",
		  i, avc->codec_id, avc->bit_rate, avc->bit_rate_tolerance,
		  avc->sample_rate, avc->channels,
		  avc->width, avc->height, avc->sample_aspect_ratio.num, avc->sample_aspect_ratio.den);

	m_Streams[i] = new FFReadStream(this, i, m_pContext->streams[i]);


    for (int i = 0; i < m_pContext->nb_streams; i++)
    {
	if (m_pContext->streams[i]->codec->codec_type == t)
	{
	    if (j == stream_id)
		return m_Streams[i];

    }

    for (int i = 0; i < m_pContext->nb_streams; i++)
	if (m_pContext->streams[i]->codec->codec_type == t)
            j++;
    return j;
}

    //else printf("Bitrate  %d\n", st->codec.bit_rate);
    //printf("TIMESTAMP %lld    %d %d   bitrate:%d\n", p->timestamp, s->m_pAvStream->r_frame_rate_base, s->m_pAvStream->r_frame_rate, st->codec.bit_rate);

    switch (st->codec->codec_type)
    {
    case CODEC_TYPE_AUDIO:
	if (!pkt.pts && st->codec->bit_rate)
	    p->timestamp = (int64_t)p->position * 8 * 1000000 /
		st->codec->bit_rate;
	s->m_uiPosition += pkt.size;
	break;
    case CODEC_TYPE_VIDEO:




//             m_pAvStream->r_frame_rate / (float) m_pAvStream->r_frame_rate_base);
    //m_pAvStream->time_length);
    //m_dLength = avs->time_length;
    //printf("CODECRA %d  %d   %d\n", avs->codec->frame_rate, avs->codec->frame_rate_base, m_pAvStream->r_frame_rate_base);
    if (0 && avs->codec->codec_id == CODEC_ID_MPEG1VIDEO)
    {
	m_pAvContext = avcodec_alloc_context();
	//AVCodec* codec = avcodec_find_encoder(avs->codec->codec_id);
	if (m_pAvContext)
	{
	    AVCodec* codec = avcodec_find_decoder(avs->codec->codec_id);
	    if (codec && avcodec_open(m_pAvContext, codec) == 0)
	    {
		m_pAvContext->flags |= CODEC_FLAG_TRUNCATED;

	m_StreamInfo.m_p->m_iQuality = 0;
	m_StreamInfo.m_p->m_iSampleSize = 1;//m_Header.dwSampleSize;

	switch (avs->codec->codec_type)
	{
	case CODEC_TYPE_AUDIO:
	    m_StreamInfo.m_p->setAudio(avs->codec->channels,
				       avs->codec->sample_rate,
				       avs->codec->frame_bits);
	    m_StreamInfo.m_p->m_Type = StreamInfo::Audio;
	    m_StreamInfo.m_p->m_uiFormat = avs->codec->codec_tag;
	    AVM_WRITE("FF stream", "Audio Format:  %.4s (0x%x)\n",
		      (const char*)&avs->codec->codec_tag, avs->codec->codec_tag);
	    break;
	case CODEC_TYPE_VIDEO:
	    m_StreamInfo.m_p->setVideo(avs->codec->width, avs->codec->height,
				       0, avs->codec->sample_aspect_ratio.num /
				       (float) avs->codec->sample_aspect_ratio.den);
	    m_StreamInfo.m_p->m_Type = StreamInfo::Video;
	    m_StreamInfo.m_p->m_uiFormat = avs->codec->codec_tag;
	    break;
	default:
            return 0;
	}
	if (m_StreamInfo.m_p->m_uiFormat == 0)
            m_StreamInfo.m_p->m_uiFormat = get_fcc(avs->codec->codec_id);
    }

    return new StreamInfo(m_StreamInfo);


IStream::StreamType FFReadStream::GetType() const
{
    switch (m_pHandler->m_pContext->streams[m_uiSId]->codec->codec_type)
    {
    case CODEC_TYPE_AUDIO: return IStream::Audio;
    case CODEC_TYPE_VIDEO: return IStream::Video;

uint_t FFReadStream::GetFormat(void *pFormat, uint_t lSize) const
{
    AVStream* avs = m_pHandler->m_pContext->streams[m_uiSId];
    switch (avs->codec->codec_type)
    {
    case CODEC_TYPE_AUDIO:
	if (pFormat && lSize >= sizeof(WAVEFORMATEX))
	{
	    WAVEFORMATEX* wf = (WAVEFORMATEX*) pFormat;
	    wf->wFormatTag = avs->codec->codec_tag;
	    if (wf->wFormatTag == 0)
                wf->wFormatTag = get_fcc(avs->codec->codec_id);
	    //if (avs->codec->codec_tag == 0) wf->wFormatTag = av_codec_get_fourcc(avs->codec->codec_id);
	    //printf("CODEC  %x   %x   %x\n", wf->wFormatTag, avs->codec->codec_id, avs->codec->codec_tag);
	    wf->nChannels = avs->codec->channels;
	    wf->nSamplesPerSec = avs->codec->sample_rate;
	    wf->nAvgBytesPerSec = avs->codec->bit_rate / 8;
            wf->nBlockAlign = avs->codec->block_align;
	    wf->wBitsPerSample = avs->codec->bits_per_sample;
	    if (lSize >= (sizeof(WAVEFORMATEX) + avs->codec->extradata_size)
		&& avs->codec->extradata)
	    {
		wf->cbSize = avs->codec->extradata_size;
		memcpy(wf + 1, avs->codec->extradata, avs->codec->extradata_size);
	    }
	    else
                wf->cbSize = 0;
	}
	//printf("EEEEEEEEEEE %d\n", avs->codec->extradata_size);
	return sizeof(WAVEFORMATEX)
	    + ((avs->codec->extradata) ? avs->codec->extradata_size : 0);
    case CODEC_TYPE_VIDEO:
	if (pFormat && lSize >= sizeof(BITMAPINFOHEADER))
	{

	    //printf("FORMAT %p  %d   %d\n", pFormat, m_uiSId, avc->width);
	    memset(bh, 0, sizeof(BITMAPINFOHEADER));
	    bh->biSize = sizeof(BITMAPINFOHEADER);
	    bh->biWidth = avs->codec->width;
	    bh->biHeight = avs->codec->height;
	    bh->biPlanes = 1;
	    bh->biCompression = avs->codec->codec_tag;
            bh->biBitCount = avs->codec->bits_per_sample;
            // hack which might be eventually usefull
	    memcpy(&bh->biXPelsPerMeter, &m_pHandler->m_pContext, sizeof(void*));
	    if (bh->biCompression == 0)
		bh->biCompression = get_fcc(avs->codec->codec_id);
	    if (lSize >= (sizeof(BITMAPINFOHEADER) + avs->codec->extradata_size)
		&& avs->codec->extradata)
	    {
		bh->biSize += avs->codec->extradata_size;
		memcpy(bh + 1, avs->codec->extradata, avs->codec->extradata_size);
		//printf("COPY EXTRA %d\n", avs->extradata_size);
		//for (unsigned i = 0; i < lSize; i++) printf("%d  0x%x\n", i, ((uint8_t*)pFormat)[i]);
	    }
	    //BitmapInfo(*bh).Print();
	}
	return sizeof(BITMAPINFOHEADER)
	    + ((avs->codec->extradata) ? avs->codec->extradata_size : 0);
    default:
	return 0;
    }

    if (m_dLength < m_dTimestamp)
	m_dLength = m_dTimestamp;

    //printf("READSTREAM  %f   sid:%d  qsz:%d  s:%d   frm: %d\n", m_dTimestamp, m_uiSId, m_Packets.size(), p->size, m_pAvStream->codec->frame_number);
    return p;
}


{
    if (time < 1.)
    {
	if (m_pAvStream->codec->codec_type == CODEC_TYPE_AUDIO)
            // check if more streams are available
            // and seek only with the video
            return 0;

Lines 245-251 int FFVideoDecoder::DecodeFrame(CImage* Link Here

(-)avifile-0.7-0.7.43-old/plugins/libffmpeg/FFVideoDecoder.cpp (-2 / +1 lines)
245	//m_pAvContext->error_concealment = 3;	245	//m_pAvContext->error_concealment = 3;
246	//m_pAvContext->workaround_bugs = FF_BUG_AUTODETECT;	246	//m_pAvContext->workaround_bugs = FF_BUG_AUTODETECT;
247	AVCodec* codec = avcodec_find_decoder_by_name(m_Info.dll);	247	AVCodec* codec = avcodec_find_decoder_by_name(m_Info.dll);
248	if (codec->options) {	248	if (0) {
249	avm::vector<AttributeInfo>::const_iterator it;	249	avm::vector<AttributeInfo>::const_iterator it;
250	for (it = m_Info.decoder_info.begin();	250	for (it = m_Info.decoder_info.begin();
251	it != m_Info.decoder_info.end(); it++)	251	it != m_Info.decoder_info.end(); it++)
Lines 267-273 int FFVideoDecoder::DecodeFrame(CImage* Link Here
267	;	267	;
268	}	268	}
269	Debug printf("pass options '%s': %s\n", it->GetName(), b);	269	Debug printf("pass options '%s': %s\n", it->GetName(), b);
270	avoption_parse(m_pAvContext, codec->options, b);
271	}	270	}
272	}	271	}
273	/*	272	/*

Lines 10-16 static void libffmpeg_set_attr(avm::vect Link Here

(-)avifile-0.7-0.7.43-old/plugins/libffmpeg/FFVideoEncoder.cpp (-3 / +1 lines)
10	{	10	{
11	if (!codec)	11	if (!codec)
12	return;	12	return;
13	const AVOption* c = codec->options;	13	const AVOption* c = NULL;
14		14
15	if (c) {	15	if (c) {
16	const AVOption *stack[FF_OPT_MAX_DEPTH];	16	const AVOption *stack[FF_OPT_MAX_DEPTH];
Lines 127-134 int FFVideoEncoder::EncodeFrame(const CI Link Here
127	//m_pAvContext->pix_fmt = PIX_FMT_YUV420P;	127	//m_pAvContext->pix_fmt = PIX_FMT_YUV420P;
128		128
129	m_pAvContext->bit_rate = 1000000;	129	m_pAvContext->bit_rate = 1000000;
130	m_pAvContext->frame_rate_base = 1000000;
131	m_pAvContext->frame_rate = (int)(m_fFps * m_pAvContext->frame_rate_base + 0.5);
132	m_pAvContext->gop_size = 250;	130	m_pAvContext->gop_size = 250;
133	m_pAvContext->qmin = 2;	131	m_pAvContext->qmin = 2;
134	m_pAvContext->qmax = 31;	132	m_pAvContext->qmax = 31;

Lines 25-31 static void libffmpeg_get_attr(avm::vect Link Here

(-)avifile-0.7-0.7.43-old/plugins/libffmpeg/fillplugins.h (-1 / +1 lines)
25	{	25	{
26	if (!codec)	26	if (!codec)
27	return;	27	return;
28	const AVOption* c = codec->options;	28	const AVOption* c = NULL;
29	if (c) {	29	if (c) {
30	const AVOption *stack[FF_OPT_MAX_DEPTH];	30	const AVOption *stack[FF_OPT_MAX_DEPTH];
31	int depth = 0;	31	int depth = 0;

Return to bug 105597

Lines 50-63 FFReadStream::FFReadStream(FFReadHandler Link Here

(-)avifile-0.7-0.7.43-old/lib/aviread/FFReadStream.cpp (-44 / +44 lines)
50	// m_pAvStream->r_frame_rate / (float) m_pAvStream->r_frame_rate_base);	50	// m_pAvStream->r_frame_rate / (float) m_pAvStream->r_frame_rate_base);
51	//m_pAvStream->time_length);	51	//m_pAvStream->time_length);
52	//m_dLength = avs->time_length;	52	//m_dLength = avs->time_length;
53	//printf("CODECRA %d %d %d\n", avs->codec.frame_rate, avs->codec.frame_rate_base, m_pAvStream->r_frame_rate_base);	53	//printf("CODECRA %d %d %d\n", avs->codec->frame_rate, avs->codec->frame_rate_base, m_pAvStream->r_frame_rate_base);
54	if (0 && avs->codec.codec_id == CODEC_ID_MPEG1VIDEO)	54	if (0 && avs->codec->codec_id == CODEC_ID_MPEG1VIDEO)
55	{	55	{
56	m_pAvContext = avcodec_alloc_context();	56	m_pAvContext = avcodec_alloc_context();
57	//AVCodec* codec = avcodec_find_encoder(avs->codec.codec_id);	57	//AVCodec* codec = avcodec_find_encoder(avs->codec->codec_id);
58	if (m_pAvContext)	58	if (m_pAvContext)
59	{	59	{
60	AVCodec* codec = avcodec_find_decoder(avs->codec.codec_id);	60	AVCodec* codec = avcodec_find_decoder(avs->codec->codec_id);
61	if (codec && avcodec_open(m_pAvContext, codec) == 0)	61	if (codec && avcodec_open(m_pAvContext, codec) == 0)
62	{	62	{
63	m_pAvContext->flags \|= CODEC_FLAG_TRUNCATED;	63	m_pAvContext->flags \|= CODEC_FLAG_TRUNCATED;
Lines 146-174 StreamInfo* FFReadStream::GetStreamInfo( Link Here
146	m_StreamInfo.m_p->m_iQuality = 0;	146	m_StreamInfo.m_p->m_iQuality = 0;
147	m_StreamInfo.m_p->m_iSampleSize = 1;//m_Header.dwSampleSize;	147	m_StreamInfo.m_p->m_iSampleSize = 1;//m_Header.dwSampleSize;
148		148
149	switch (avs->codec.codec_type)	149	switch (avs->codec->codec_type)
150	{	150	{
151	case CODEC_TYPE_AUDIO:	151	case CODEC_TYPE_AUDIO:
152	m_StreamInfo.m_p->setAudio(avs->codec.channels,	152	m_StreamInfo.m_p->setAudio(avs->codec->channels,
153	avs->codec.sample_rate,	153	avs->codec->sample_rate,
154	avs->codec.frame_bits);	154	avs->codec->frame_bits);
155	m_StreamInfo.m_p->m_Type = StreamInfo::Audio;	155	m_StreamInfo.m_p->m_Type = StreamInfo::Audio;
156	m_StreamInfo.m_p->m_uiFormat = avs->codec.codec_tag;	156	m_StreamInfo.m_p->m_uiFormat = avs->codec->codec_tag;
157	AVM_WRITE("FF stream", "Audio Format: %.4s (0x%x)\n",	157	AVM_WRITE("FF stream", "Audio Format: %.4s (0x%x)\n",
158	(const char*)&avs->codec.codec_tag, avs->codec.codec_tag);	158	(const char*)&avs->codec->codec_tag, avs->codec->codec_tag);
159	break;	159	break;
160	case CODEC_TYPE_VIDEO:	160	case CODEC_TYPE_VIDEO:
161	m_StreamInfo.m_p->setVideo(avs->codec.width, avs->codec.height,	161	m_StreamInfo.m_p->setVideo(avs->codec->width, avs->codec->height,
162	0, avs->codec.sample_aspect_ratio.num /	162	0, avs->codec->sample_aspect_ratio.num /
163	(float) avs->codec.sample_aspect_ratio.den);	163	(float) avs->codec->sample_aspect_ratio.den);
164	m_StreamInfo.m_p->m_Type = StreamInfo::Video;	164	m_StreamInfo.m_p->m_Type = StreamInfo::Video;
165	m_StreamInfo.m_p->m_uiFormat = avs->codec.codec_tag;	165	m_StreamInfo.m_p->m_uiFormat = avs->codec->codec_tag;
166	break;	166	break;
167	default:	167	default:
168	return 0;	168	return 0;
169	}	169	}
170	if (m_StreamInfo.m_p->m_uiFormat == 0)	170	if (m_StreamInfo.m_p->m_uiFormat == 0)
171	m_StreamInfo.m_p->m_uiFormat = get_fcc(avs->codec.codec_id);	171	m_StreamInfo.m_p->m_uiFormat = get_fcc(avs->codec->codec_id);
172	}	172	}
173		173
174	return new StreamInfo(m_StreamInfo);	174	return new StreamInfo(m_StreamInfo);
Lines 189-195 uint_t FFReadStream::GetSampleSize() con Link Here
189		189
190	IStream::StreamType FFReadStream::GetType() const	190	IStream::StreamType FFReadStream::GetType() const
191	{	191	{
192	switch (m_pHandler->m_pContext->streams[m_uiSId]->codec.codec_type)	192	switch (m_pHandler->m_pContext->streams[m_uiSId]->codec->codec_type)
193	{	193	{
194	case CODEC_TYPE_AUDIO: return IStream::Audio;	194	case CODEC_TYPE_AUDIO: return IStream::Audio;
195	case CODEC_TYPE_VIDEO: return IStream::Video;	195	case CODEC_TYPE_VIDEO: return IStream::Video;
Lines 200-233 IStream::StreamType FFReadStream::GetTyp Link Here
200	uint_t FFReadStream::GetFormat(void *pFormat, uint_t lSize) const	200	uint_t FFReadStream::GetFormat(void *pFormat, uint_t lSize) const
201	{	201	{
202	AVStream* avs = m_pHandler->m_pContext->streams[m_uiSId];	202	AVStream* avs = m_pHandler->m_pContext->streams[m_uiSId];
203	switch (avs->codec.codec_type)	203	switch (avs->codec->codec_type)
204	{	204	{
205	case CODEC_TYPE_AUDIO:	205	case CODEC_TYPE_AUDIO:
206	if (pFormat && lSize >= sizeof(WAVEFORMATEX))	206	if (pFormat && lSize >= sizeof(WAVEFORMATEX))
207	{	207	{
208	WAVEFORMATEX* wf = (WAVEFORMATEX*) pFormat;	208	WAVEFORMATEX* wf = (WAVEFORMATEX*) pFormat;
209	wf->wFormatTag = avs->codec.codec_tag;	209	wf->wFormatTag = avs->codec->codec_tag;
210	if (wf->wFormatTag == 0)	210	if (wf->wFormatTag == 0)
211	wf->wFormatTag = get_fcc(avs->codec.codec_id);	211	wf->wFormatTag = get_fcc(avs->codec->codec_id);
212	//if (avs->codec.codec_tag == 0) wf->wFormatTag = av_codec_get_fourcc(avs->codec.codec_id);	212	//if (avs->codec->codec_tag == 0) wf->wFormatTag = av_codec_get_fourcc(avs->codec->codec_id);
213	//printf("CODEC %x %x %x\n", wf->wFormatTag, avs->codec.codec_id, avs->codec.codec_tag);	213	//printf("CODEC %x %x %x\n", wf->wFormatTag, avs->codec->codec_id, avs->codec->codec_tag);
214	wf->nChannels = avs->codec.channels;	214	wf->nChannels = avs->codec->channels;
215	wf->nSamplesPerSec = avs->codec.sample_rate;	215	wf->nSamplesPerSec = avs->codec->sample_rate;
216	wf->nAvgBytesPerSec = avs->codec.bit_rate / 8;	216	wf->nAvgBytesPerSec = avs->codec->bit_rate / 8;
217	wf->nBlockAlign = avs->codec.block_align;	217	wf->nBlockAlign = avs->codec->block_align;
218	wf->wBitsPerSample = avs->codec.bits_per_sample;	218	wf->wBitsPerSample = avs->codec->bits_per_sample;
219	if (lSize >= (sizeof(WAVEFORMATEX) + avs->codec.extradata_size)	219	if (lSize >= (sizeof(WAVEFORMATEX) + avs->codec->extradata_size)
220	&& avs->codec.extradata)	220	&& avs->codec->extradata)
221	{	221	{
222	wf->cbSize = avs->codec.extradata_size;	222	wf->cbSize = avs->codec->extradata_size;
223	memcpy(wf + 1, avs->codec.extradata, avs->codec.extradata_size);	223	memcpy(wf + 1, avs->codec->extradata, avs->codec->extradata_size);
224	}	224	}
225	else	225	else
226	wf->cbSize = 0;	226	wf->cbSize = 0;
227	}	227	}
228	//printf("EEEEEEEEEEE %d\n", avs->codec.extradata_size);	228	//printf("EEEEEEEEEEE %d\n", avs->codec->extradata_size);
229	return sizeof(WAVEFORMATEX)	229	return sizeof(WAVEFORMATEX)
230	+ ((avs->codec.extradata) ? avs->codec.extradata_size : 0);	230	+ ((avs->codec->extradata) ? avs->codec->extradata_size : 0);
231	case CODEC_TYPE_VIDEO:	231	case CODEC_TYPE_VIDEO:
232	if (pFormat && lSize >= sizeof(BITMAPINFOHEADER))	232	if (pFormat && lSize >= sizeof(BITMAPINFOHEADER))
233	{	233	{
Lines 235-261 uint_t FFReadStream::GetFormat(void *pFo Link Here
235	//printf("FORMAT %p %d %d\n", pFormat, m_uiSId, avc->width);	235	//printf("FORMAT %p %d %d\n", pFormat, m_uiSId, avc->width);
236	memset(bh, 0, sizeof(BITMAPINFOHEADER));	236	memset(bh, 0, sizeof(BITMAPINFOHEADER));
237	bh->biSize = sizeof(BITMAPINFOHEADER);	237	bh->biSize = sizeof(BITMAPINFOHEADER);
238	bh->biWidth = avs->codec.width;	238	bh->biWidth = avs->codec->width;
239	bh->biHeight = avs->codec.height;	239	bh->biHeight = avs->codec->height;
240	bh->biPlanes = 1;	240	bh->biPlanes = 1;
241	bh->biCompression = avs->codec.codec_tag;	241	bh->biCompression = avs->codec->codec_tag;
242	bh->biBitCount = avs->codec.bits_per_sample;	242	bh->biBitCount = avs->codec->bits_per_sample;
243	// hack which might be eventually usefull	243	// hack which might be eventually usefull
244	memcpy(&bh->biXPelsPerMeter, &m_pHandler->m_pContext, sizeof(void*));	244	memcpy(&bh->biXPelsPerMeter, &m_pHandler->m_pContext, sizeof(void*));
245	if (bh->biCompression == 0)	245	if (bh->biCompression == 0)
246	bh->biCompression = get_fcc(avs->codec.codec_id);	246	bh->biCompression = get_fcc(avs->codec->codec_id);
247	if (lSize >= (sizeof(BITMAPINFOHEADER) + avs->codec.extradata_size)	247	if (lSize >= (sizeof(BITMAPINFOHEADER) + avs->codec->extradata_size)
248	&& avs->codec.extradata)	248	&& avs->codec->extradata)
249	{	249	{
250	bh->biSize += avs->codec.extradata_size;	250	bh->biSize += avs->codec->extradata_size;
251	memcpy(bh + 1, avs->codec.extradata, avs->codec.extradata_size);	251	memcpy(bh + 1, avs->codec->extradata, avs->codec->extradata_size);
252	//printf("COPY EXTRA %d\n", avs->extradata_size);	252	//printf("COPY EXTRA %d\n", avs->extradata_size);
253	//for (unsigned i = 0; i < lSize; i++) printf("%d 0x%x\n", i, ((uint8_t*)pFormat)[i]);	253	//for (unsigned i = 0; i < lSize; i++) printf("%d 0x%x\n", i, ((uint8_t*)pFormat)[i]);
254	}	254	}
255	//BitmapInfo(*bh).Print();	255	//BitmapInfo(*bh).Print();
256	}	256	}
257	return sizeof(BITMAPINFOHEADER)	257	return sizeof(BITMAPINFOHEADER)
258	+ ((avs->codec.extradata) ? avs->codec.extradata_size : 0);	258	+ ((avs->codec->extradata) ? avs->codec->extradata_size : 0);
259	default:	259	default:
260	return 0;	260	return 0;
261	}	261	}
Lines 291-297 StreamPacket* FFReadStream::ReadPacket() Link Here
291	if (m_dLength < m_dTimestamp)	291	if (m_dLength < m_dTimestamp)
292	m_dLength = m_dTimestamp;	292	m_dLength = m_dTimestamp;
293		293
294	//printf("READSTREAM %f sid:%d qsz:%d s:%d frm: %d\n", m_dTimestamp, m_uiSId, m_Packets.size(), p->size, m_pAvStream->codec.frame_number);	294	//printf("READSTREAM %f sid:%d qsz:%d s:%d frm: %d\n", m_dTimestamp, m_uiSId, m_Packets.size(), p->size, m_pAvStream->codec->frame_number);
295	return p;	295	return p;
296	}	296	}
297		297
Lines 310-316 int FFReadStream::SeekTime(double time) Link Here
310	{	310	{
311	if (time < 1.)	311	if (time < 1.)
312	{	312	{
313	if (m_pAvStream->codec.codec_type == CODEC_TYPE_AUDIO)	313	if (m_pAvStream->codec->codec_type == CODEC_TYPE_AUDIO)
314	// check if more streams are available	314	// check if more streams are available
315	// and seek only with the video	315	// and seek only with the video
316	return 0;	316	return 0;

Lines 66-75 int FFReadHandler::Init(const char* url) Link Here

(-)avifile-0.7-0.7.43-old/lib/aviread/FFReadHandler.cpp (-8 / +8 lines)
66	m_Streams.resize(m_pContext->nb_streams);	66	m_Streams.resize(m_pContext->nb_streams);
67	for (int i = 0; i < m_pContext->nb_streams; i++)	67	for (int i = 0; i < m_pContext->nb_streams; i++)
68	{	68	{
69	AVCodecContext* avc = &m_pContext->streams[i]->codec;	69	AVCodecContext* avc = m_pContext->streams[i]->codec;
70	AVM_WRITE("FF reader", "S: %d id:%x bitrate:%d (%d) samprate:%d chn:%d framerate:%d wxh %dx%d %d/%d\n",	70	AVM_WRITE("FF reader", "S: %d id:%x bitrate:%d (%d) samprate:%d chn:%d wxh %dx%d %d/%d\n",
71	i, avc->codec_id, avc->bit_rate, avc->bit_rate_tolerance,	71	i, avc->codec_id, avc->bit_rate, avc->bit_rate_tolerance,
72	avc->sample_rate, avc->channels, avc->frame_rate,	72	avc->sample_rate, avc->channels,
73	avc->width, avc->height, avc->sample_aspect_ratio.num, avc->sample_aspect_ratio.den);	73	avc->width, avc->height, avc->sample_aspect_ratio.num, avc->sample_aspect_ratio.den);
74		74
75	m_Streams[i] = new FFReadStream(this, i, m_pContext->streams[i]);	75	m_Streams[i] = new FFReadStream(this, i, m_pContext->streams[i]);
Lines 106-112 IMediaReadStream* FFReadHandler::GetStre Link Here
106		106
107	for (int i = 0; i < m_pContext->nb_streams; i++)	107	for (int i = 0; i < m_pContext->nb_streams; i++)
108	{	108	{
109	if (m_pContext->streams[i]->codec.codec_type == t)	109	if (m_pContext->streams[i]->codec->codec_type == t)
110	{	110	{
111	if (j == stream_id)	111	if (j == stream_id)
112	return m_Streams[i];	112	return m_Streams[i];
Lines 130-136 uint_t FFReadHandler::GetStreamCount(ISt Link Here
130	}	130	}
131		131
132	for (int i = 0; i < m_pContext->nb_streams; i++)	132	for (int i = 0; i < m_pContext->nb_streams; i++)
133	if (m_pContext->streams[i]->codec.codec_type == t)	133	if (m_pContext->streams[i]->codec->codec_type == t)
134	j++;	134	j++;
135	return j;	135	return j;
136	}	136	}
Lines 203-214 int FFReadHandler::readPacket() Link Here
203	//else printf("Bitrate %d\n", st->codec.bit_rate);	203	//else printf("Bitrate %d\n", st->codec.bit_rate);
204	//printf("TIMESTAMP %lld %d %d bitrate:%d\n", p->timestamp, s->m_pAvStream->r_frame_rate_base, s->m_pAvStream->r_frame_rate, st->codec.bit_rate);	204	//printf("TIMESTAMP %lld %d %d bitrate:%d\n", p->timestamp, s->m_pAvStream->r_frame_rate_base, s->m_pAvStream->r_frame_rate, st->codec.bit_rate);
205		205
206	switch (st->codec.codec_type)	206	switch (st->codec->codec_type)
207	{	207	{
208	case CODEC_TYPE_AUDIO:	208	case CODEC_TYPE_AUDIO:
209	if (!pkt.pts && st->codec.bit_rate)	209	if (!pkt.pts && st->codec->bit_rate)
210	p->timestamp = (int64_t)p->position * 8 * 1000000 /	210	p->timestamp = (int64_t)p->position * 8 * 1000000 /
211	st->codec.bit_rate;	211	st->codec->bit_rate;
212	s->m_uiPosition += pkt.size;	212	s->m_uiPosition += pkt.size;
213	break;	213	break;
214	case CODEC_TYPE_VIDEO:	214	case CODEC_TYPE_VIDEO: