Debian Codegraph @

lib/aviread/FFReadHandler.cpp

raw ◀ ▶
Source reconstructed at patch state 2 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 avformat_close_input(&m_pContext);
66 }
67 }
68
69 int FFReadHandler::Init(const char* url)
70 {
71 AVInputFormat* fmt = 0;
72
73 // av_find_input_format(url);
74 //printf("find input format %p %s\n", fmt, b);
75 int r = avformat_open_input(&m_pContext, url,
76 fmt, NULL);
77 if (r < 0)
78 {
79 AVM_WRITE("FF reader", "Open Input failed %d\n", r);
80 return -1;
81 }
82
83 if (avformat_find_stream_info(m_pContext, NULL) < 0)
84 return -1;
85
86 AVM_WRITE("FF reader", "Format:'%s' Stream(s):%d\n", m_pContext->iformat->long_name, m_pContext->nb_streams);
87
88 m_Streams.resize(m_pContext->nb_streams);
89 for (unsigned i = 0; i < m_pContext->nb_streams; ++i)
90 {
91 AVCodecContext* avc = m_pContext->streams[i]->codec;
92 AVCodec* codec = avcodec_find_decoder(avc->codec_id);
93 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",
94 i, codec ? codec->name : "", avc->codec_id, avc->bit_rate, avc->bit_rate_tolerance,
95 avc->sample_rate, avc->channels, avc->time_base.num, avc->time_base.den,
96 avc->width, avc->height, avc->sample_aspect_ratio.num, avc->sample_aspect_ratio.den);
97 m_Streams[i] = new FFReadStream(this, i, m_pContext->streams[i]);
98 }
99
100 //m_pContext->iformat->read_header(m_pContext, &avfp);
101 //printf("samprate %d\nchn %d\nframerate %d\nwidth %d\nheigth %d\n",
102 // avfp.sample_rate, avfp.channels, avfp.frame_rate, avfp.width, avfp.height);
103 return 0;
104 }
105
106 size_t FFReadHandler::GetHeader(void* header, size_t size)
107 {
108 if (header)//&& (size >= sizeof(AVIMainHeader)))
109 {
110 memset(header, 0, size);
111 //memcpy(pheader, &m_MainHeader, sizeof(AVIMainHeader));
112 }
113 return 0;//sizeof(AVIMainHeader);
114 }
115
116 IMediaReadStream* FFReadHandler::GetStream(uint_t stream_id,
117 IStream::StreamType type)
118 {
119 int t;
120 uint_t cnt = 0;
121 switch (type)
122 {
123 case IStream::Audio: t = AVMEDIA_TYPE_AUDIO; break;
124 case IStream::Video: t = AVMEDIA_TYPE_VIDEO; break;
125 default: return 0;
126 }
127
128 for (unsigned i = 0; i < m_pContext->nb_streams; ++i)
129 {
130 if (m_pContext->streams[i]->codec->codec_type == t)
131 {
132 if (cnt == stream_id)
133 return m_Streams[i];
134 cnt++;
135 }
136 }
137
138 return 0;
139 }
140
141 size_t FFReadHandler::GetStreamCount(IStream::StreamType type)
142 {
143 int t;
144 size_t cnt = 0;
145
146 switch (type)
147 {
148 case IStream::Audio: t = AVMEDIA_TYPE_AUDIO; break;
149 case IStream::Video: t = AVMEDIA_TYPE_VIDEO; break;
150 default: return 0;
151 }
152
153 for (unsigned i = 0; i < m_pContext->nb_streams; ++i)
154 if (m_pContext->streams[i]->codec->codec_type == t)
155 cnt++;
156 return cnt;
157 }
158
159 void FFReadHandler::flush()
160 {
161 for (size_t i = 0; i < m_Streams.size(); ++i)
162 {
163 while (m_Streams[i]->m_Packets.size())
164 {
165 m_Streams[i]->m_Packets.front()->Release();
166 m_Streams[i]->m_Packets.pop();
167 }
168 m_Streams[i]->m_uiPosition = 0;
169 }
170 }
171
172 //int FFReadHandler::seek(framepos_t pos)
173 int FFReadHandler::seek(double timepos)
174 {
175 Locker locker(m_Mutex);
176 flush();
177 //AVM_WRITE("FF reader", 1, "seek(%f) %" PRId64 "\n", timepos, m_pContext->start_time);
178 int64_t sp = ((m_pContext->start_time != (int64_t)AV_NOPTS_VALUE)
179 ? m_pContext->start_time : 0) + int64_t(timepos * AV_TIME_BASE);
180 #if 1
181 av_seek_frame(m_pContext, -1, sp, 0);
182 #else
183 #ifndef INT64_MIN
184 #define INT64_MIN (-0x7fffffffffffffffLL-1)
185 #endif
186 #ifndef INT64_MAX
187 #define INT64_MAX INT64_C(9223372036854775807)
188 #endif
189 avformat_seek_file(m_pContext, -1, INT64_MIN, sp, INT64_MAX, 0);
190 #endif
191 return 0;
192 }
193
194 int FFReadHandler::readPacket()
195 {
196 Locker locker(m_Mutex);
197 AVStreamPacket* p = new AVStreamPacket();
198 AVPacket& pkt = p->GetAVPacket();
199 AVM_WRITE("FF reader", 5, "readPacket()\n");
200 if (av_read_frame(m_pContext, &pkt) < 0)
201 {
202 p->Release();
203 if (m_pContext->pb && m_pContext->pb->error)
204 AVM_WRITE("FF reader", "error seen\n");
205
206 //if (!url_feof(m_pContext->pb))
207 // AVM_WRITE("FF reader", "ffmpeg packet error and not eof??\n");
208
209 return -1;
210 }
211
212 //printf("FFMPEG pktsize: %u %" PRId64 " %d\n", pkt.size, pkt.pts, pkt.stream_index);fflush(stdout);
213
214 p->UpdateMembers();
215
216 if ((size_t)pkt.stream_index >= m_Streams.size()) {
217 AVM_WRITE("FF reader", "new stream?? i:%d n:%d sz:%" PRIsz "\n",
218 pkt.stream_index, m_pContext->nb_streams, m_Streams.size());
219 p->Release();
220 return 0;
221 }
222
223 FFReadStream& s = *m_Streams[pkt.stream_index];
224 AVStream& ast = *m_pContext->streams[pkt.stream_index];
225
226 p->SetPos(s.m_uiPosition);
227 p->SetTimestamp(((pkt.pts != (int64_t)AV_NOPTS_VALUE) ? pkt.pts : pkt.dts)
228 * AV_TIME_BASE * ast.time_base.num / ast.time_base.den - s.GetStartTime());
229 if (pkt.flags & AV_PKT_FLAG_KEY)
230 p->SetFlags(p->GetFlags() | KEYFRAME);
231
232 if (p->GetTimestamp() < 0)
233 p->SetTimestamp(0);
234
235 //AVM_WRITE("FF reader", "st:%d n/d:%d/%d ts:%" PRId64 " d:%" PRId64 " dur:%d p:%" PRId64 "\n",
236 // pkt.stream_index, ast.time_base.num, ast.time_base.den,
237 // p->timestamp, pkt.dts, pkt.duration, pkt.pts);
238 //if (ast->codec.codec_type == AVMEDIA_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);
239 //else printf("Bitrate %d\n", ast->codec.bit_rate);
240 //printf("TIMESTAMP %" PRId64 " pts: %" PRId64 " dts: %" PRId64 "\n", p->timestamp, pkt.pts, pkt.dts);
241
242 switch (ast.codec->codec_type)
243 {
244 case AVMEDIA_TYPE_AUDIO:
245 s.m_uiPosition += pkt.size;
246 break;
247 case AVMEDIA_TYPE_VIDEO:
248 default:
249 s.m_uiPosition++;
250 break;
251 }
252 #if 0
253 printf("---ReadPacket i:%d sz:%d pts:%" PRId64 " size:%d (%" PRId64 ", %d)\n",
254 pkt.stream_index, s.m_Packets.size(), pkt.pts, pkt.size, p->timestamp, pkt.flags);
255 #endif
256
257 if (s.m_Packets.size() >= s.m_Packets.capacity() - 1)
258 {
259 if (1)
260 AVM_WRITE("FF reader", "got too many packets in the queue %d??? (%" PRIsz ", %" PRIsz ")\n",
261 pkt.stream_index, s.m_Packets.size(), s.m_Packets.capacity());
262 s.m_Packets.front()->Release();
263 s.m_Packets.pop();
264 }
265
266 s.m_Packets.push(p);
267 return 0;
268 }
269
270 IMediaReadHandler* CreateFFReadHandler(const char *pszFile)
271 {
272 FFReadHandler* h = new FFReadHandler();
273 if (h && h->Init(pszFile) == 0)
274 return h;
275
276 delete h;
277 return 0;
278 }
279
280 AVM_END_NAMESPACE;