Debian Codegraph @

lib/aviread/FFReadStream.cpp

raw ◀ ▶
Source reconstructed at patch state 5 of 7 — not the installed (fully patched) source.
7 Debian patches touch this file
1 #include "FFReadStream.h"
2 #include "FFReadHandler.h"
3 #include "avm_fourcc.h"
4 #include "avm_output.h"
5 #include "utils.h"
6
7 #include "avm_avformat.h"
8 #include "avm_avcodec.h"
9
10 #include <stdio.h>
11 #include <stdlib.h>
12 #include <string.h>
13
14 AVM_BEGIN_NAMESPACE;
15
16 static int get_fcc(enum AVCodecID id)
17 {
18 const struct id2fcc {
19 enum AVCodecID id;
20 uint32_t fcc;
21 } id2fcct[] = {
22 { AV_CODEC_ID_MPEG1VIDEO, RIFFINFO_MPG1 },
23 { AV_CODEC_ID_MPEG1VIDEO, mmioFOURCC('P', 'I', 'M', '1') },
24 { AV_CODEC_ID_MPEG2VIDEO, RIFFINFO_MPG2 },
25 { AV_CODEC_ID_H263, mmioFOURCC('H', '2', '6', '3') },
26 { AV_CODEC_ID_H263P, mmioFOURCC('H', '2', '6', '3') },
27 { AV_CODEC_ID_H263I, mmioFOURCC('I', '2', '6', '3') },
28 { AV_CODEC_ID_H264, mmioFOURCC('H', '2', '6', '4') },
29 { AV_CODEC_ID_MSMPEG4V3, mmioFOURCC('D', 'I', 'V', '3') },
30 { AV_CODEC_ID_MPEG4, mmioFOURCC('D', 'I', 'V', 'X') },
31 { AV_CODEC_ID_MSMPEG4V2, mmioFOURCC('M', 'P', '4', '2') },
32 { AV_CODEC_ID_FLV1, mmioFOURCC('F', 'L', 'V', '1') },
33 { AV_CODEC_ID_MJPEG, mmioFOURCC('M', 'J', 'P', 'G') },
34 { AV_CODEC_ID_DTS, 0x10 },
35 { AV_CODEC_ID_MP2, 0x50 },
36 { AV_CODEC_ID_MP3, 0x55 },
37 { AV_CODEC_ID_AC3, WAVE_FORMAT_DVM },
38 { AV_CODEC_ID_AAC, 'M' | ('P' << 8) }, // MP4A
39 { AV_CODEC_ID_DVVIDEO, mmioFOURCC('D', 'V', 'S', 'D') },
40 { AV_CODEC_ID_DVAUDIO, ('D' << 8) | 'A' },
41 { AV_CODEC_ID_NONE }
42 };
43 //printf("TRANSLATE %d 0x%x\n", id, id);
44 for (const struct id2fcc* p = id2fcct; p->id; p++)
45 if (p->id == id)
46 return p->fcc;
47 //printf("FAILED\n");
48 return 0;
49 }
50
51 FFReadStream::FFReadStream(FFReadHandler* handler, uint_t sid, AVStream* avs)
52 : m_pHandler(handler), m_pAvStream(avs), m_pAvContext(0), m_uiSId(sid),
53 m_Packets(5000), m_uiPosition(0), m_dTimestamp(0.),
54 m_uiKeyChunks(0), m_uiKeySize(0), m_uiKeyMaxSize(0), m_uiKeyMinSize(0),
55 m_uiDeltaSize(0), m_uiDeltaMaxSize(0), m_uiDeltaMinSize(0)
56 {
57 m_StartTime = (m_pHandler->m_pContext->start_time != (int64_t)AV_NOPTS_VALUE)
58 ? m_pHandler->m_pContext->start_time : 0;
59 m_dLength = (double)m_pHandler->m_pContext->duration / (double)AV_TIME_BASE;
60
61 AVM_WRITE("FF stream", "Starttime:%" PRId64 " Duration:%fs\n", m_StartTime, m_dLength);
62 //printf("codec %d %.4s\n", avs->codec->codec_id, &avs->codec->codec_tag);
63 //printf("CODECRA %d %d %d\n", avs->codec->frame_rate, avs->codec->frame_rate_base, avs->r_frame_rate_base);
64 if (0 && avs->codecpar->codec_id == AV_CODEC_ID_MPEG1VIDEO)
65 {
66 m_pAvContext = avcodec_alloc_context3(NULL);
67 //AVCodec* codec = avcodec_find_encoder(avs->codec->codec_id);
68 if (m_pAvContext)
69 {
70 const AVCodec* codec = avcodec_find_decoder(avs->codecpar->codec_id);
71 if (codec && avcodec_open2(m_pAvContext, codec, NULL) == 0)
72 {
73 m_pAvContext->flags |= AV_CODEC_FLAG_TRUNCATED;
74 m_pAvContext->skip_frame = AVDISCARD_NONKEY;
75 //printf("Opened hurryup decoder %p %p\n", codec, m_pAvContext->codec->decode);
76 }
77 else
78 {
79 avcodec_close(m_pAvContext);
80 m_pAvContext = 0;
81 }
82 }
83 }
84 }
85
86 FFReadStream::~FFReadStream()
87 {
88 if (m_pAvContext)
89 {
90 avcodec_close(m_pAvContext);
91 free(m_pAvContext);
92 }
93 }
94
95 double FFReadStream::CacheSize() const
96 {
97 return 1.; //(double)m_Packets.size() / (double)m_Packets.capacity() + 0.2;
98 }
99
100 void FFReadStream::ClearCache()
101 {
102 }
103
104 size_t FFReadStream::GetHeader(void* header, size_t size) const
105 {
106 return 0;
107 }
108
109 framepos_t FFReadStream::GetPrevKeyFrame(framepos_t frame) const
110 {
111 return ERR;
112 }
113
114 framepos_t FFReadStream::GetNextKeyFrame(framepos_t frame) const
115 {
116 return ERR;
117 }
118
119 framepos_t FFReadStream::GetNearestKeyFrame(framepos_t frame) const
120 {
121 return ERR;
122 }
123
124 framepos_t FFReadStream::GetLength() const
125 {
126 return 0x7fffffff;
127 }
128
129 double FFReadStream::GetFrameTime() const
130 {
131 return 1/24.;
132 }
133
134 double FFReadStream::GetLengthTime() const
135 {
136 return m_dLength;
137 }
138
139 StreamInfo* FFReadStream::GetStreamInfo() const
140 {
141 AVStream* avs = m_pHandler->m_pContext->streams[m_uiSId];
142 uint_t s;
143 if (m_StreamInfo.m_p->m_dLengthTime == 0.0)
144 {
145 m_StreamInfo.m_p->setKfFrames(m_uiKeyMaxSize, m_uiKeyMinSize,
146 m_uiKeyChunks, m_uiKeySize);
147
148 m_StreamInfo.m_p->setFrames(m_uiDeltaMaxSize,
149 (m_uiDeltaMinSize > m_uiDeltaMaxSize)
150 // usually no delta frames
151 ? m_uiDeltaMaxSize : m_uiDeltaMinSize,
152 (uint_t)(m_Offsets.size() - m_uiKeyChunks),
153 m_uiStreamSize - m_uiKeySize);
154
155 m_StreamInfo.m_p->m_dLengthTime = GetLengthTime();
156 m_StreamInfo.m_p->m_iQuality = 0;
157 m_StreamInfo.m_p->m_iSampleSize = 1;//m_Header.dwSampleSize;
158
159 switch (avs->codecpar->codec_type)
160 {
161 case AVMEDIA_TYPE_AUDIO:
162 m_StreamInfo.m_p->setAudio(avs->codecpar->ch_layout.nb_channels,
163 avs->codecpar->sample_rate,
164 avs->codecpar->frame_size);
165 m_StreamInfo.m_p->m_Type = StreamInfo::Audio;
166 m_StreamInfo.m_p->m_uiFormat = avs->codecpar->codec_tag;
167 AVM_WRITE("FF stream", "Audio Format: %.4s (0x%x)\n",
168 (const char*)&avs->codecpar->codec_tag, avs->codecpar->codec_tag);
169 break;
170 case AVMEDIA_TYPE_VIDEO:
171 m_StreamInfo.m_p->setVideo(avs->codecpar->width, avs->codecpar->height,
172 0, (float)avs->codecpar->sample_aspect_ratio.num /
173 (float)avs->codecpar->sample_aspect_ratio.den);
174 m_StreamInfo.m_p->m_Type = StreamInfo::Video;
175 m_StreamInfo.m_p->m_uiFormat = avs->codecpar->codec_tag;
176 AVM_WRITE("FF stream", "Codec tag format %.4s\n", (char*) &m_StreamInfo.m_p->m_uiFormat);
177 break;
178 default:
179 return 0;
180 }
181 if (m_StreamInfo.m_p->m_uiFormat == 0) {
182 m_StreamInfo.m_p->m_uiFormat = get_fcc(avs->codecpar->codec_id);
183
184 if (m_StreamInfo.m_p->m_uiFormat == 0)
185 AVM_WRITE("FF stream", "StreamInfo extension neeeded\n");
186 }
187 }
188
189 return new StreamInfo(m_StreamInfo);
190 }
191
192 double FFReadStream::GetTime(framepos_t lSample) const
193 {
194 if (lSample == ERR)
195 return m_dTimestamp;
196
197 return 0.;
198 }
199
200 size_t FFReadStream::GetSampleSize() const
201 {
202 return 0;
203 }
204
205 IStream::StreamType FFReadStream::GetType() const
206 {
207 switch (m_pHandler->m_pContext->streams[m_uiSId]->codecpar->codec_type)
208 {
209 case AVMEDIA_TYPE_AUDIO: return IStream::Audio;
210 case AVMEDIA_TYPE_VIDEO: return IStream::Video;
211 default: return IStream::Other;
212 }
213 }
214
215 size_t FFReadStream::GetFormat(void *format, size_t size) const
216 {
217 AVStream* avs = m_pHandler->m_pContext->streams[m_uiSId];
218
219 int tag = get_fcc(avs->codecpar->codec_id);
220 switch (avs->codecpar->codec_type)
221 {
222 case AVMEDIA_TYPE_AUDIO:
223 if (format && size >= sizeof(WAVEFORMATEX))
224 {
225 WAVEFORMATEX& wfx = *(WAVEFORMATEX*)format;
226 FFMPEGWAVEFORMATEX& ffwfx = *(FFMPEGWAVEFORMATEX*)format;
227 if (tag == 0) {
228 if (size < sizeof(FFMPEGWAVEFORMATEX))
229 return 0;
230 memset(&ffwfx, 0, sizeof(ffwfx));
231 // using extension - there is no free place in original WAVEFORMATEX
232 wfx.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
233 avm_set_le32(&ffwfx.wfex.SubFormat.f1, CodecInfo::FFMPEG);
234 avm_set_le32(&ffwfx.dwCodecID, avs->codecpar->codec_id);
235 } else {
236 memset(&wfx, 0, sizeof(wfx));
237 wfx.wFormatTag = (uint16_t)tag;
238 }
239
240 //if (avs->codec->codec_tag == 0) wf->wFormatTag = av_codec_get_fourcc(avs->codec->codec_id);
241 //printf("CODEC %x %x %x\n", wf.wFormatTag, avs->codec->codec_id, avs->codec->codec_tag);
242 wfx.nChannels = (uint16_t)avs->codecpar->ch_layout.nb_channels;
243 wfx.nSamplesPerSec = avs->codecpar->sample_rate;
244 wfx.nAvgBytesPerSec = avs->codecpar->bit_rate / 8;
245 //printf("SAMP:%d AVGBYTES:%d ALIGN:%d BITS:%d\n", avs->codec->sample_rate, avs->codec->bit_rate, avs->codecpar->block_align, avs->codec->bits_per_coded_sample);
246 wfx.nBlockAlign = (uint16_t)avs->codecpar->block_align;
247 wfx.wBitsPerSample = (uint16_t)avs->codecpar->bits_per_coded_sample;
248 wfx.cbSize = tag ? 0 : sizeof(FFMPEGWAVEFORMATEX) - sizeof(WAVEFORMATEX);
249 if (avs->codecpar->extradata
250 && size >= (sizeof(WAVEFORMATEX) + wfx.cbSize + avs->codecpar->extradata_size))
251 {
252 memcpy((uint8_t*)(&wfx + 1) + wfx.cbSize, avs->codecpar->extradata, avs->codecpar->extradata_size);
253 wfx.cbSize = (uint16_t)(wfx.cbSize + avs->codecpar->extradata_size);
254 }
255
256 if (avs->codecpar->codec_id == AV_CODEC_ID_AAC) {
257 // hmm currenly hack - ffmpeg seems to fail properly detect this stream
258 wfx.nChannels = 2;
259 wfx.nSamplesPerSec = 44100;
260 wfx.nAvgBytesPerSec = 16000;
261 wfx.wBitsPerSample = 16;
262 }
263
264 ///printf("AUDIO %d %x %x %d\n", avs->codec->extradata_size, wf->wFormatTag, avs->codec->codec_tag, avs->codec->codec_id);
265 }
266 return (tag ? sizeof(WAVEFORMATEX) : sizeof(FFMPEGWAVEFORMATEX))
267 + ((avs->codecpar->extradata) ? avs->codecpar->extradata_size : 0);
268 case AVMEDIA_TYPE_VIDEO:
269 if (format && size >= sizeof(BITMAPINFOHEADER))
270 {
271 memset(format, 0, sizeof(BITMAPINFOHEADER));
272 BITMAPINFOHEADER& bih = *(BITMAPINFOHEADER*)format;
273 //printf("FORMAT %p %d %d\n", format, m_uiSId, avc->width);
274 bih.biSize = sizeof(BITMAPINFOHEADER);
275 bih.biWidth = avs->codecpar->width;
276 bih.biHeight = avs->codecpar->height;
277 bih.biPlanes = 1;
278 bih.biCompression = get_fcc(avs->codecpar->codec_id);
279 bih.biBitCount = (uint16_t)avs->codecpar->bits_per_coded_sample;
280 // hack which might be eventually usefull
281 //memcpy(&bih->biXPelsPerMeter, &m_pHandler->m_pContext, sizeof(void*));
282 if (!bih.biCompression) {
283 bih.biCompression = CodecInfo::FFMPEG;
284 bih.biSizeImage = avs->codecpar->codec_id;
285 }
286 if (avs->codecpar->extradata && size >= (sizeof(BITMAPINFOHEADER) + avs->codecpar->extradata_size))
287 {
288 bih.biSize += avs->codecpar->extradata_size;
289 memcpy(&bih + 1, avs->codecpar->extradata, avs->codecpar->extradata_size);
290 //printf("COPY EXTRA %d\n", avs->extradata_size);
291 //for (unsigned i = 0; i < size; i++) printf("%d 0x%x\n", i, ((uint8_t*)format)[i]);
292 }
293 //BitmapInfo(*bih).Print();
294 }
295 return sizeof(BITMAPINFOHEADER)
296 + ((avs->codecpar->extradata) ? avs->codecpar->extradata_size : 0);
297 default:
298 return 0;
299 }
300 }
301
302 bool FFReadStream::IsKeyFrame(framepos_t frame) const
303 {
304 if (frame == ERR && m_Packets.size())
305 return (m_Packets.front()->GetFlags() & KEYFRAME);
306
307 AVM_WRITE("FF stream", "IsKeyFrame unimplemented!\n");
308 return true;
309 }
310
311 StreamPacket* FFReadStream::ReadPacket()
312 {
313 for (size_t i = 0; i < m_Packets.capacity() - 2; ++i)
314 {
315 if (m_Packets.size() > 0)
316 break;
317
318 if (m_pHandler->readPacket() < 0)
319 {
320 if (m_dLength < m_dTimestamp)
321 m_dLength = m_dTimestamp;
322 return 0;
323 }
324 }
325 //printf("PACKET SIZE %d %d\n", m_Packets.size(), m_Packets.capacity());
326 if (!m_Packets.size())
327 return 0;
328
329 Locker locker(m_pHandler->m_Mutex);
330 StreamPacket* p = m_Packets.front();
331 m_Packets.pop();
332 m_dTimestamp = (double)p->GetTimestamp() / (double)AV_TIME_BASE;
333
334 if (m_dLength < m_dTimestamp)
335 m_dLength = m_dTimestamp;
336
337 //printf("FFREADSTREAMPACKET %f sid:%d qsz:%" PRIsz " s:%d frm: %d\n", m_dTimestamp, m_uiSId, m_Packets.size(), p->size, m_pAvStream->codec->frame_number);
338 return p;
339 }
340
341 int FFReadStream::Seek(framepos_t pos)
342 {
343 AVM_WRITE("FF stream", "SeekPos: %d\n", pos);
344 if (pos == 0)
345 {
346 m_pHandler->seek(0);
347 return 0;
348 }
349 return -1;
350 }
351
352 int FFReadStream::SeekTime(double time)
353 {
354 AVM_WRITE("FF stream", "SeekTime: %f\n", time);
355 return m_pHandler->seek(time);
356 if (time < 1.)
357 {
358 if (m_pAvStream->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
359 // check if more streams are available
360 // and seek only with the video
361 return 0;
362 m_pHandler->seek(0);
363 return 0;
364 }
365 return -1;
366 }
367
368 int FFReadStream::SkipFrame()
369 {
370 AVM_WRITE("FF stream", "SkipFrame\n");
371 StreamPacket* p = ReadPacket();
372 if (p)
373 p->Release();
374 return p ? 0 : -1;
375 }
376
377 int FFReadStream::SkipTo(double pos)
378 {
379 AVM_WRITE("FF stream", "SkipTo: %f\n", pos);
380 while (pos < GetTime())
381 SkipFrame();
382 return 0;
383 }
384
385 AVM_END_NAMESPACE;