| 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; |