Debian Codegraph @

lib/aviread/AsfFileInputStream.cpp

raw
1 #include "Cache.h" // first for lseek64 support
2
3 #include "AsfFileInputStream.h"
4 #include "asf_guids.h"
5 #include "avm_output.h"
6 #include "utils.h"
7
8 #include <fcntl.h>
9 #include <unistd.h>
10 #include <sys/types.h>
11 #include <sys/stat.h>
12
13 #include <string.h>
14 #include <stdio.h>
15 #include <stdlib.h>
16
17 #ifndef O_LARGEFILE
18 #define O_LARGEFILE 0
19 #endif
20
21 AVM_BEGIN_NAMESPACE;
22
23 #define __MODULE__ "AsfFileInputStream"
24
25
26 AsfIterator::~AsfIterator()
27 {
28 }
29
30 AsfInputStream::~AsfInputStream()
31 {
32 }
33
34
35 class FileIterator: public AsfIterator
36 {
37 public:
38 FileIterator(AsfFileInputStream* parent, int id)
39 : AsfIterator(id), m_lPos(0), m_pParent(parent),
40 m_SeekInfo(m_pParent->m_SeekInfo[id])
41 {
42 }
43 virtual const AsfStreamSeekInfo* getSeekInfo() { return m_SeekInfo; }
44 virtual AsfPacket* getPacket()
45 {
46 const ASFMainHeader& header = m_pParent->m_Header;
47 //printf("Id: %d PID %d\n", m_iId, getpid());
48 //printf("Pos packer id: %d pos : %d (of %d sz: %d)\n",
49 // m_iId, m_lPos, header.pkts_count, m_SeekInfo->size());
50 //if (m_lPos >= 0 || m_lPos < (int)header.pkts_count)
51 AsfPacket* p = new AsfPacket(header.max_pktsize);
52 if (!p)
53 return 0;
54
55 //AVM_WRITE("ASF file reader", "GET PACKET %lld size: %d\n", m_lPos, header.min_pktsize);
56
57 m_pParent->m_Mutex.Lock();
58 int64_t pos = m_pParent->m_lDataOffset + m_lPos * header.max_pktsize;
59 lseek64(m_pParent->m_iFd, pos, SEEK_SET);
60 //printf("SEEK SET %lld %llx\n", pos, pos);
61 ssize_t i = read(m_pParent->m_iFd, &(*p)[0], header.max_pktsize);
62 m_pParent->m_Mutex.Unlock();
63
64 if (i != (ssize_t) header.max_pktsize
65 || p->init() != 0)
66 {
67 if (!m_bEof )
68 AVM_WRITE("ASF file reader", "incorrect packet (%" PRId64 ") at: %" PRId64 " byte\n", m_lPos, pos);
69 // FIXME - missing check for unix signal and restart - maybe add later
70 // usually happens with EOF - handle better...
71 //AVM_WRITE("ASF network reader", "asfinput:: read fail %d\n", header.pktsize);
72 p->release();
73 m_bEof = true;
74 return 0;
75 }
76
77 m_lPos++;
78 return p;
79 }
80 virtual int seek(framepos_t pos, chunk_info* pch)
81 {
82 if (pos >= m_SeekInfo->size())
83 return -1;
84
85 const chunk_info& ch = (*m_SeekInfo)[pos];
86 m_lPos = ch.packet_id;
87 *pch = ch;
88 m_bEof = false;
89 //AVM_WRITE("ASF file reader", "Seekpos %lld time %d %d\n", m_lPos, ch.object_start_time/1000, pos);
90
91 return 0;
92 }
93 virtual int seekTime(double timestamp, chunk_info* pch)
94 {
95 return seek(m_SeekInfo->find(uint_t(timestamp*1000.)), pch);
96 }
97
98 protected:
99 int64_t m_lPos;
100 AsfFileInputStream* m_pParent;
101 AsfStreamSeekInfo* m_SeekInfo;
102 };
103
104 /* first, we make a completely stupid implementation */
105 AsfFileInputStream::AsfFileInputStream()
106 :m_iFd(-1), m_SeekInfo(128)
107 {
108 for (size_t i = 0; i < m_SeekInfo.size(); ++i)
109 m_SeekInfo[i] = 0;
110 }
111
112 int AsfFileInputStream::init(const char* pszFile)
113 {
114 m_iFd = open(pszFile, O_RDONLY | O_LARGEFILE);
115 if (m_iFd < 0)
116 {
117 AVM_WRITE("ASF reader", "Could not open the file\n");
118 return -1;
119 }
120 uint8_t* header = 0;
121 ssize_t r;
122 m_lDataOffset = 0;
123
124 for (;;)
125 {
126 GUID guid;
127 int64_t size;
128 if (read(m_iFd, &guid, 16) <= 0 || read(m_iFd, &size, 8) <= 0)
129 break;
130 avm_get_leGUID(&guid);
131 size = avm_get_le64(&size) - 24;
132 if (size < 0)
133 break;
134 //char buf[100];printf("GUID type %d %s\n", (int) guid_get_guidid(&guid), guid_to_string(buf, &guid));
135 AVM_WRITE("ASF reader", 1, "Object: %s - object size: %5" PRId64 "\n", guidid_to_text(guid_get_guidid(&guid)), size);
136
137 switch (guid_get_guidid(&guid))
138 {
139 case GUID_ASF_HEADER:
140 if ((header = new uint8_t[size]))
141 {
142 r = read(m_iFd, header, size);
143 if (r <= 0 || !parseHeader(header, (uint_t) r))
144 {
145 delete[] header;
146 header = 0;
147 }
148 }
149 break;
150 case GUID_ASF_DATA:
151 if (size < 26 || !header)
152 {
153 AVM_WRITE("ASF reader", "Wrong data chunk size\n");
154 return -1;
155 }
156 m_lDataOffset = lseek64(m_iFd, 0, SEEK_CUR) + 26;
157 lseek64(m_iFd, size, SEEK_CUR);
158 break;
159 case GUID_ERROR: //unknown chunk type
160 default:
161 if (!header)
162 break;
163 lseek64(m_iFd, size, SEEK_CUR);
164 break;
165 }
166 }
167 if (!header)
168 {
169 AVM_WRITE("ASF reader", 1, "Could not find ASF header chunk in file\n");
170 return -1;
171 }
172 if (!m_lDataOffset)
173 {
174 AVM_WRITE("ASF reader", "Could not find data chunk in file\n");
175 return -1;
176 }
177 delete[] header;
178 createSeekData();
179 return 0;
180 }
181
182 #undef __MODULE__
183
184 AsfFileInputStream::~AsfFileInputStream()
185 {
186 if (m_iFd >= 0)
187 close(m_iFd);
188 for (unsigned i = 0; i < m_SeekInfo.size(); i++)
189 delete m_SeekInfo[i];
190 }
191
192 void AsfFileInputStream::createSeekData()
193 {
194 uint_t last_start[m_SeekInfo.size()];
195 for (unsigned l = 0; l < m_SeekInfo.size(); l++)
196 last_start[l] = 0;
197 for (unsigned l = 0; l < m_Streams.size(); l++)
198 m_SeekInfo[m_Streams[l].hdr.stream & 0x7f]
199 = new AsfStreamSeekInfo();
200
201 AVM_WRITE("ASF reader", "Creating seek data, please wait...\n");
202 AsfIterator* it = getIterator(~0U);//argument only needed in seek operations
203 AsfPacket* p = 0;
204 unsigned i;
205
206 for (i = 0; /*i < m_Header.pkts_count*/; i++)
207 {
208 if (p)
209 p->release();
210 p = it->getPacket();
211 if (!p)
212 break;
213 for (unsigned j = 0; j < p->fragments.size(); j++)
214 {
215 const AsfPacketFragment& f = p->fragments[j];
216 chunk_info ch;
217 if (f.object_length != f.data_length && f.fragment_offset)
218 continue;
219
220 if (!m_SeekInfo[f.stream_id])
221 {
222 AVM_WRITE("ASF reader", "WARNING: Unexpected stream_id ( packet %d, send time %f"
223 ", fragment: %d, stream_id: %d)\n",
224 i, p->send_time/1000., j, f.stream_id);
225 continue;
226 }
227
228 ch.object_start_time = f.object_start_time - m_Header.preroll;
229 ch.object_length = f.object_length;
230 //AVM_WRITE("ASF reader", "id:%d %d starttm: %f len: %d idx: %d kf:%d\n", f.stream_id, m_SeekInfo[f.stream_id]->size(), ch.object_start_time/1000.0, ch.object_length, j, f.keyframe);
231 if (last_start[f.stream_id] > 0)
232 {
233 if (ch.object_start_time < last_start[f.stream_id])
234 {
235 AVM_WRITE("ASF reader", "WARNING: Negative send time difference ( packet %d"
236 ", packet send time: %f, fragment: %d, stream_id: %d "
237 ", fragment send time: %f, last fragment send time: %f)\n",
238 i, p->send_time/1000., j, (int)f.stream_id,
239 ch.object_start_time/1000.,
240 m_SeekInfo[f.stream_id]->back().object_start_time/1000.);
241 //continue;
242 ch.object_start_time = last_start[f.stream_id];
243 }
244 }
245 // note - keyframe flag must be set after object_length!
246 ch.SetKeyFrame(f.keyframe);
247 ch.packet_id = i;
248 ch.fragment_id = (uint16_t) j;
249 //printf("packet %d %d %d\n", i, j, f.fragment_offset);
250 last_start[f.stream_id] = ch.object_start_time;
251 m_SeekInfo[f.stream_id]->push_back(ch);
252 }
253 }
254 if (p)
255 p->release();
256 #if 0
257 AsfStreamSeekInfo* si = m_SeekInfo[1];
258 for (unsigned i = 0; i < si->size() && i < 200; i++)
259 {
260 chunk_info& c = si->operator[](i);
261
262 cout << i << " " << c.packet_id << " " << c.object_start_time << " "
263 << (int)c.keyframe << endl;
264 }
265 #endif
266
267 m_Header.pkts_count = i;
268 AVM_WRITE("ASF reader", "Seek data created ( processed %d packets )\n", i);
269 it->release();
270 }
271
272 AsfIterator* AsfFileInputStream::getIterator(uint_t id)
273 {
274 if (id >= m_Streams.size())
275 return (id == ~0U) ? new FileIterator(this, 0) : 0;
276
277 int sid = m_Streams[id].hdr.stream & 0x7f;
278 return (m_SeekInfo[sid] && m_SeekInfo[sid]->size()) ?
279 new FileIterator(this, sid) : 0;
280 }
281
282 AVM_END_NAMESPACE;