Debian Codegraph @

lib/aviread/FFReadHandler.cpp

raw ◀ ▶
Source reconstructed at patch state 0 of 3 — not the installed (fully patched) source.
3 Debian patches touch this file
1 #include "FFReadHandler.h"
2 #include "FFReadStream.h"
3 #include "avm_output.h"
4
5 #include "avm_avformat.h"
6
7 #include <stdlib.h>
8 #include <string.h>
9 #include <unistd.h>
10
11 AVM_BEGIN_NAMESPACE;
12
13 class AVStreamPacket : public StreamPacket
14 {
15 AVPacket packet;
16
17 /// \internal disabled
18 AVStreamPacket(const AVStreamPacket&) {}
19 /// \internal disabled
20 AVStreamPacket& operator=(const AVStreamPacket&) { return *this; }
21
22 public:
23 AVStreamPacket() : StreamPacket() {}
24 virtual ~AVStreamPacket() {
25 if (memory)
26 {
27 av_free_packet(&packet);
28 memory = 0;
29 }
30 }
31
32 AVPacket& GetAVPacket() { return packet; }
33 const AVPacket& GetAVPacket() const { return packet; }
34 void UpdateMembers() {
35 memory = packet.data;
36 size = packet.size;
37 read = 0;
38 }
39 };
40
41
42 FFReadHandler::FFReadHandler()
43 : m_pContext(0)
44 {
45 static int g_iInitilized = 0;
46
47 if (!g_iInitilized)
48 {
49 av_register_all();
50 g_iInitilized++;
51 }
52 }
53
54 FFReadHandler::~FFReadHandler()
55 {
56 if (m_pContext)
57 {
58 flush();
59
60 while (m_Streams.size() > 0)
61 {
62 delete m_Streams.back();
63 m_Streams.pop_back();
64 }
65 av_close_input_file(m_pContext);
66 }
67 }
68
69 int FFReadHandler::Init(const char* url)
70 {
71 AVFormatParameters avfp;
72 AVInputFormat* fmt = 0;
73
74 // av_find_input_format(url);
75 //printf("find input format %p %s\n", fmt, b);
76 memset(&avfp, 0, sizeof(avfp));
77 int r = av_open_input_file(&m_pContext, url,
78 fmt, 64000, &avfp);
79 if (r < 0)
80 {
81 AVM_WRITE("FF reader", "Open Input failed %d\n", r);
82 return -1;
83 }
84
85 if (av_find_stream_info(m_pContext) < 0)
86 return -1;
87
88 AVM_WRITE("FF reader", "Format:'%s' Stream(s):%d\n", m_pContext->iformat->long_name, m_pContext->nb_streams);
89
90 m_Streams.resize(m_pContext->nb_streams);
91 for (unsigned i = 0; i < m_pContext->nb_streams; ++i)
92 {
93 AVCodecContext* avc = m_pContext->streams[i]->codec;
94 AVCodec* codec = avcodec_find_decoder(avc->codec_id);
95 AVM_WRITE("FF reader", "S: %d %s CodecID:%x bitrate:%d (%d) samplerate:%d chn:%d framerate:%d/%d wxh %dx%d %d/%d\n",
96 i, codec ? codec->name : "", avc->codec_id, avc->bit_rate, avc->bit_rate_tolerance,
97 avc->sample_rate, avc->channels, avc->time_base.num, avc->time_base.den,
98 avc->width, avc->height, avc->sample_aspect_ratio.num, avc->sample_aspect_ratio.den);
99 m_Streams[i] = new FFReadStream(this, i, m_pContext->streams[i]);
100 }
101
102 //m_pContext->iformat->read_header(m_pContext, &avfp);
103 //printf("samprate %d\nchn %d\nframerate %d\nwidth %d\nheigth %d\n",
104 // avfp.sample_rate, avfp.channels, avfp.frame_rate, avfp.width, avfp.height);
105 return 0;
106 }
107
108 size_t FFReadHandler::GetHeader(void* header, size_t size)
109 {
110 if (header)//&& (size >= sizeof(AVIMainHeader)))
111 {
112 memset(header, 0, size);
113 //memcpy(pheader, &m_MainHeader, sizeof(AVIMainHeader));
114 }
115 return 0;//sizeof(AVIMainHeader);
116 }
117
118 IMediaReadStream* FFReadHandler::GetStream(uint_t stream_id,
119 IStream::StreamType type)
120 {
121 int t;
122 uint_t cnt = 0;
123 switch (type)
124 {
125 case IStream::Audio: t = CODEC_TYPE_AUDIO; break;
126 case IStream::Video: t = CODEC_TYPE_VIDEO; break;
127 default: return 0;
128 }
129
130 for (unsigned i = 0; i < m_pContext->nb_streams; ++i)
131 {
132 if (m_pContext->streams[i]->codec->codec_type == t)
133 {
134 if (cnt == stream_id)
135 return m_Streams[i];
136 cnt++;
137 }
138 }
139
140 return 0;
141 }
142
143 size_t FFReadHandler::GetStreamCount(IStream::StreamType type)
144 {
145 int t;
146 size_t cnt = 0;
147
148 switch (type)
149 {
150 case IStream::Audio: t = CODEC_TYPE_AUDIO; break;
151 case IStream::Video: t = CODEC_TYPE_VIDEO; break;
152 default: return 0;
153 }
154
155 for (unsigned i = 0; i < m_pContext->nb_streams; ++i)
156 if (m_pContext->streams[i]->codec->codec_type == t)
157 cnt++;
158 return cnt;
159 }
160
161 void FFReadHandler::flush()
162 {
163 for (size_t i = 0; i < m_Streams.size(); ++i)
164 {
165 while (m_Streams[i]->m_Packets.size())
166 {
167 m_Streams[i]->m_Packets.front()->Release();
168 m_Streams[i]->m_Packets.pop();
169 }
170 m_Streams[i]->m_uiPosition = 0;
171 }
172 }
173
174 //int FFReadHandler::seek(framepos_t pos)
175 int FFReadHandler::seek(double timepos)
176 {
177 Locker locker(m_Mutex);
178 flush();
179 //AVM_WRITE("FF reader", 1, "seek(%f) %" PRId64 "\n", timepos, m_pContext->start_time);
180 int64_t sp = ((m_pContext->start_time != (int64_t)AV_NOPTS_VALUE)
181 ? m_pContext->start_time : 0) + int64_t(timepos * AV_TIME_BASE);
182 #if 1
183 av_seek_frame(m_pContext, -1, sp, 0);
184 #else
185 #ifndef INT64_MIN
186 #define INT64_MIN (-0x7fffffffffffffffLL-1)
187 #endif
188 #ifndef INT64_MAX
189 #define INT64_MAX INT64_C(9223372036854775807)
190 #endif
191 avformat_seek_file(m_pContext, -1, INT64_MIN, sp, INT64_MAX, 0);
192 #endif
193 return 0;
194 }
195
196 int FFReadHandler::readPacket()
197 {
198 Locker locker(m_Mutex);
199 AVStreamPacket* p = new AVStreamPacket();
200 AVPacket& pkt = p->GetAVPacket();
201 AVM_WRITE("FF reader", 5, "readPacket()\n");
202 if (av_read_frame(m_pContext, &pkt) < 0)
203 {
204 p->Release();
205 if (url_ferror(m_pContext->pb))
206 AVM_WRITE("FF reader", "error seen\n");
207
208 //if (!url_feof(m_pContext->pb))
209 // AVM_WRITE("FF reader", "ffmpeg packet error and not eof??\n");
210
211 return -1;
212 }
213
214 //printf("FFMPEG pktsize: %u %" PRId64 " %d\n", pkt.size, pkt.pts, pkt.stream_index);fflush(stdout);
215
216 p->UpdateMembers();
217
218 if ((size_t)pkt.stream_index >= m_Streams.size()) {
219 AVM_WRITE("FF reader", "new stream?? i:%d n:%d sz:%" PRIsz "\n",
220 pkt.stream_index, m_pContext->nb_streams, m_Streams.size());
221 p->Release();
222 return 0;
223 }
224
225 FFReadStream& s = *m_Streams[pkt.stream_index];
226 AVStream& ast = *m_pContext->streams[pkt.stream_index];
227
228 p->SetPos(s.m_uiPosition);
229 p->SetTimestamp(((pkt.pts != (int64_t)AV_NOPTS_VALUE) ? pkt.pts : pkt.dts)
230 * AV_TIME_BASE * ast.time_base.num / ast.time_base.den - s.GetStartTime());
231 if (pkt.flags & PKT_FLAG_KEY)
232 p->SetFlags(p->GetFlags() | KEYFRAME);
233
234 if (p->GetTimestamp() < 0)
235 p->SetTimestamp(0);
236
237 //AVM_WRITE("FF reader", "st:%d n/d:%d/%d ts:%" PRId64 " d:%" PRId64 " dur:%d p:%" PRId64 "\n",
238 // pkt.stream_index, ast.time_base.num, ast.time_base.den,
239 // p->timestamp, pkt.dts, pkt.duration, pkt.pts);
240 //if (ast->codec.codec_type == CODEC_TYPE_VIDEO) printf("FRATE %d pts:%lld %d %d t:%lld\n", p->position, pkt.pts,ast->codec.frame_rate_base, ast->codec.frame_rate, p->timestamp);
241 //else printf("Bitrate %d\n", ast->codec.bit_rate);
242 //printf("TIMESTAMP %" PRId64 " pts: %" PRId64 " dts: %" PRId64 "\n", p->timestamp, pkt.pts, pkt.dts);
243
244 switch (ast.codec->codec_type)
245 {
246 case CODEC_TYPE_AUDIO:
247 s.m_uiPosition += pkt.size;
248 break;
249 case CODEC_TYPE_VIDEO:
250 default:
251 s.m_uiPosition++;
252 break;
253 }
254 #if 0
255 printf("---ReadPacket i:%d sz:%d pts:%" PRId64 " size:%d (%" PRId64 ", %d)\n",
256 pkt.stream_index, s.m_Packets.size(), pkt.pts, pkt.size, p->timestamp, pkt.flags);
257 #endif
258
259 if (s.m_Packets.size() >= s.m_Packets.capacity() - 1)
260 {
261 if (1)
262 AVM_WRITE("FF reader", "got too many packets in the queue %d??? (%" PRIsz ", %" PRIsz ")\n",
263 pkt.stream_index, s.m_Packets.size(), s.m_Packets.capacity());
264 s.m_Packets.front()->Release();
265 s.m_Packets.pop();
266 }
267
268 s.m_Packets.push(p);
269 return 0;
270 }
271
272 IMediaReadHandler* CreateFFReadHandler(const char *pszFile)
273 {
274 FFReadHandler* h = new FFReadHandler();
275 if (h && h->Init(pszFile) == 0)
276 return h;
277
278 delete h;
279 return 0;
280 }
281
282 AVM_END_NAMESPACE;