Debian Codegraph @

lib/aviread/FFReadStream.cpp

raw ◀ ▶
Source reconstructed at patch state 6 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->skip_frame = AVDISCARD_NONKEY;
74 //printf("Opened hurryup decoder %p %p\n", codec, m_pAvContext->codec->decode);
75 }
76 else
77 {
78 avcodec_close(m_pAvContext);
79 m_pAvContext = 0;
80 }
81 }
82 }
83 }
84
85 FFReadStream::~FFReadStream()
86 {
87 if (m_pAvContext)
88 {
89 avcodec_close(m_pAvContext);
90 free(m_pAvContext);
91 }
92 }
93
94 double FFReadStream::CacheSize() const
95 {
96 return 1.; //(double)m_Packets.size() / (double)m_Packets.capacity() + 0.2;
97 }
98
99 void FFReadStream::ClearCache()
100 {
101 }
102
103 size_t FFReadStream::GetHeader(void* header, size_t size) const
104 {
105 return 0;
106 }
107
108 framepos_t FFReadStream::GetPrevKeyFrame(framepos_t frame) const
109 {
110 return ERR;
111 }
112
113 framepos_t FFReadStream::GetNextKeyFrame(framepos_t frame) const
114 {
115 return ERR;
116 }
117
118 framepos_t FFReadStream::GetNearestKeyFrame(framepos_t frame) const
119 {
120 return ERR;
121 }
122
123 framepos_t FFReadStream::GetLength() const
124 {
125 return 0x7fffffff;
126 }
127
128 double FFReadStream::GetFrameTime() const
129 {
130 return 1/24.;
131 }
132
133 double FFReadStream::GetLengthTime() const
134 {
135 return m_dLength;
136 }
137
138 StreamInfo* FFReadStream::GetStreamInfo() const
139 {
140 AVStream* avs = m_pHandler->m_pContext->streams[m_uiSId];
141 uint_t s;
142 if (m_StreamInfo.m_p->m_dLengthTime == 0.0)
143 {
144 m_StreamInfo.m_p->setKfFrames(m_uiKeyMaxSize, m_uiKeyMinSize,
145 m_uiKeyChunks, m_uiKeySize);
146
147 m_StreamInfo.m_p->setFrames(m_uiDeltaMaxSize,
148 (m_uiDeltaMinSize > m_uiDeltaMaxSize)
149 // usually no delta frames
150 ? m_uiDeltaMaxSize : m_uiDeltaMinSize,
151 (uint_t)(m_Offsets.size() - m_uiKeyChunks),
152 m_uiStreamSize - m_uiKeySize);
153
154 m_StreamInfo.m_p->m_dLengthTime = GetLengthTime();
155 m_StreamInfo.m_p->m_iQuality = 0;
156 m_StreamInfo.m_p->m_iSampleSize = 1;//m_Header.dwSampleSize;
157
158 switch (avs->codecpar->codec_type)
159 {
160 case AVMEDIA_TYPE_AUDIO:
161 m_StreamInfo.m_p->setAudio(avs->codecpar->ch_layout.nb_channels,
162 avs->codecpar->sample_rate,
163 avs->codecpar->frame_size);
164 m_StreamInfo.m_p->m_Type = StreamInfo::Audio;
165 m_StreamInfo.m_p->m_uiFormat = avs->codecpar->codec_tag;
166 AVM_WRITE("FF stream", "Audio Format: %.4s (0x%x)\n",
167 (const char*)&avs->codecpar->codec_tag, avs->codecpar->codec_tag);
168 break;
169 case AVMEDIA_TYPE_VIDEO:
170 m_StreamInfo.m_p->setVideo(avs->codecpar->width, avs->codecpar->height,
171 0, (float)avs->codecpar->sample_aspect_ratio.num /
172 (float)avs->codecpar->sample_aspect_ratio.den);
173 m_StreamInfo.m_p->m_Type = StreamInfo::Video;
174 m_StreamInfo.m_p->m_uiFormat = avs->codecpar->codec_tag;
175 AVM_WRITE("FF stream", "Codec tag format %.4s\n", (char*) &m_StreamInfo.m_p->m_uiFormat);
176 break;
177 default:
178 return 0;
179 }
180 if (m_StreamInfo.m_p->m_uiFormat == 0) {
181 m_StreamInfo.m_p->m_uiFormat = get_fcc(avs->codecpar->codec_id);
182
183 if (m_StreamInfo.m_p->m_uiFormat == 0)
184 AVM_WRITE("FF stream", "StreamInfo extension neeeded\n");
185 }
186 }
187
188 return new StreamInfo(m_StreamInfo);
189 }
190
191 double FFReadStream::GetTime(framepos_t lSample) const
192 {
193 if (lSample == ERR)
194 return m_dTimestamp;
195
196 return 0.;
197 }
198
199 size_t FFReadStream::GetSampleSize() const
200 {
201 return 0;
202 }
203
204 IStream::StreamType FFReadStream::GetType() const
205 {
206 switch (m_pHandler->m_pContext->streams[m_uiSId]->codecpar->codec_type)
207 {
208 case AVMEDIA_TYPE_AUDIO: return IStream::Audio;
209 case AVMEDIA_TYPE_VIDEO: return IStream::Video;
210 default: return IStream::Other;
211 }
212 }
213
214 size_t FFReadStream::GetFormat(void *format, size_t size) const
215 {
216 AVStream* avs = m_pHandler->m_pContext->streams[m_uiSId];
217
218 int tag = get_fcc(avs->codecpar->codec_id);
219 switch (avs->codecpar->codec_type)
220 {
221 case AVMEDIA_TYPE_AUDIO:
222 if (format && size >= sizeof(WAVEFORMATEX))
223 {
224 WAVEFORMATEX& wfx = *(WAVEFORMATEX*)format;
225 FFMPEGWAVEFORMATEX& ffwfx = *(FFMPEGWAVEFORMATEX*)format;
226 if (tag == 0) {
227 if (size < sizeof(FFMPEGWAVEFORMATEX))
228 return 0;
229 memset(&ffwfx, 0, sizeof(ffwfx));
230 // using extension - there is no free place in original WAVEFORMATEX
231 wfx.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
232 avm_set_le32(&ffwfx.wfex.SubFormat.f1, CodecInfo::FFMPEG);
233 avm_set_le32(&ffwfx.dwCodecID, avs->codecpar->codec_id);
234 } else {
235 memset(&wfx, 0, sizeof(wfx));
236 wfx.wFormatTag = (uint16_t)tag;
237 }
238
239 //if (avs->codec->codec_tag == 0) wf->wFormatTag = av_codec_get_fourcc(avs->codec->codec_id);
240 //printf("CODEC %x %x %x\n", wf.wFormatTag, avs->codec->codec_id, avs->codec->codec_tag);
241 wfx.nChannels = (uint16_t)avs->codecpar->ch_layout.nb_channels;
242 wfx.nSamplesPerSec = avs->codecpar->sample_rate;
243 wfx.nAvgBytesPerSec = avs->codecpar->bit_rate / 8;
244 //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);
245 wfx.nBlockAlign = (uint16_t)avs->codecpar->block_align;
246 wfx.wBitsPerSample = (uint16_t)avs->codecpar->bits_per_coded_sample;
247 wfx.cbSize = tag ? 0 : sizeof(FFMPEGWAVEFORMATEX) - sizeof(WAVEFORMATEX);
248 if (avs->codecpar->extradata
249 && size >= (sizeof(WAVEFORMATEX) + wfx.cbSize + avs->codecpar->extradata_size))
250 {
251 memcpy((uint8_t*)(&wfx + 1) + wfx.cbSize, avs->codecpar->extradata, avs->codecpar->extradata_size);
252 wfx.cbSize = (uint16_t)(wfx.cbSize + avs->codecpar->extradata_size);
253 }
254
255 if (avs->codecpar->codec_id == AV_CODEC_ID_AAC) {
256 // hmm currenly hack - ffmpeg seems to fail properly detect this stream
257 wfx.nChannels = 2;
258 wfx.nSamplesPerSec = 44100;
259 wfx.nAvgBytesPerSec = 16000;
260 wfx.wBitsPerSample = 16;
261 }
262
263 ///printf("AUDIO %d %x %x %d\n", avs->codec->extradata_size, wf->wFormatTag, avs->codec->codec_tag, avs->codec->codec_id);
264 }
265 return (tag ? sizeof(WAVEFORMATEX) : sizeof(FFMPEGWAVEFORMATEX))
266 + ((avs->codecpar->extradata) ? avs->codecpar->extradata_size : 0);
267 case AVMEDIA_TYPE_VIDEO:
268 if (format && size >= sizeof(BITMAPINFOHEADER))
269 {
270 memset(format, 0, sizeof(BITMAPINFOHEADER));
271 BITMAPINFOHEADER& bih = *(BITMAPINFOHEADER*)format;
272 //printf("FORMAT %p %d %d\n", format, m_uiSId, avc->width);
273 bih.biSize = sizeof(BITMAPINFOHEADER);
274 bih.biWidth = avs->codecpar->width;
275 bih.biHeight = avs->codecpar->height;
276 bih.biPlanes = 1;
277 bih.biCompression = get_fcc(avs->codecpar->codec_id);
278 bih.biBitCount = (uint16_t)avs->codecpar->bits_per_coded_sample;
279 // hack which might be eventually usefull
280 //memcpy(&bih->biXPelsPerMeter, &m_pHandler->m_pContext, sizeof(void*));
281 if (!bih.biCompression) {
282 bih.biCompression = CodecInfo::FFMPEG;
283 bih.biSizeImage = avs->codecpar->codec_id;
284 }
285 if (avs->codecpar->extradata && size >= (sizeof(BITMAPINFOHEADER) + avs->codecpar->extradata_size))
286 {
287 bih.biSize += avs->codecpar->extradata_size;
288 memcpy(&bih + 1, avs->codecpar->extradata, avs->codecpar->extradata_size);
289 //printf("COPY EXTRA %d\n", avs->extradata_size);
290 //for (unsigned i = 0; i < size; i++) printf("%d 0x%x\n", i, ((uint8_t*)format)[i]);
291 }
292 //BitmapInfo(*bih).Print();
293 }
294 return sizeof(BITMAPINFOHEADER)
295 + ((avs->codecpar->extradata) ? avs->codecpar->extradata_size : 0);
296 default:
297 return 0;
298 }
299 }
300
301 bool FFReadStream::IsKeyFrame(framepos_t frame) const
302 {
303 if (frame == ERR && m_Packets.size())
304 return (m_Packets.front()->GetFlags() & KEYFRAME);
305
306 AVM_WRITE("FF stream", "IsKeyFrame unimplemented!\n");
307 return true;
308 }
309
310 StreamPacket* FFReadStream::ReadPacket()
311 {
312 for (size_t i = 0; i < m_Packets.capacity() - 2; ++i)
313 {
314 if (m_Packets.size() > 0)
315 break;
316
317 if (m_pHandler->readPacket() < 0)
318 {
319 if (m_dLength < m_dTimestamp)
320 m_dLength = m_dTimestamp;
321 return 0;
322 }
323 }
324 //printf("PACKET SIZE %d %d\n", m_Packets.size(), m_Packets.capacity());
325 if (!m_Packets.size())
326 return 0;
327
328 Locker locker(m_pHandler->m_Mutex);
329 StreamPacket* p = m_Packets.front();
330 m_Packets.pop();
331 m_dTimestamp = (double)p->GetTimestamp() / (double)AV_TIME_BASE;
332
333 if (m_dLength < m_dTimestamp)
334 m_dLength = m_dTimestamp;
335
336 //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);
337 return p;
338 }
339
340 int FFReadStream::Seek(framepos_t pos)
341 {
342 AVM_WRITE("FF stream", "SeekPos: %d\n", pos);
343 if (pos == 0)
344 {
345 m_pHandler->seek(0);
346 return 0;
347 }
348 return -1;
349 }
350
351 int FFReadStream::SeekTime(double time)
352 {
353 AVM_WRITE("FF stream", "SeekTime: %f\n", time);
354 return m_pHandler->seek(time);
355 if (time < 1.)
356 {
357 if (m_pAvStream->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
358 // check if more streams are available
359 // and seek only with the video
360 return 0;
361 m_pHandler->seek(0);
362 return 0;
363 }
364 return -1;
365 }
366
367 int FFReadStream::SkipFrame()
368 {
369 AVM_WRITE("FF stream", "SkipFrame\n");
370 StreamPacket* p = ReadPacket();
371 if (p)
372 p->Release();
373 return p ? 0 : -1;
374 }
375
376 int FFReadStream::SkipTo(double pos)
377 {
378 AVM_WRITE("FF stream", "SkipTo: %f\n", pos);
379 while (pos < GetTime())
380 SkipFrame();
381 return 0;
382 }
383
384 AVM_END_NAMESPACE;