Debian Codegraph @

lib/aviread/FFReadStream.cpp

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