Debian Codegraph @

lib/aviread/asffmt.cpp

raw
1 #include "asffmt.h"
2 #include "utils.h"
3 #include "avm_output.h"
4
5 #include <string.h>
6 #include <stdio.h>
7
8 #define Debug if (0)
9
10 AVM_BEGIN_NAMESPACE;
11
12 AsfPacket::AsfPacket(size_t psize)
13 : avm::vector<uint8_t>(psize), refcount(1)
14 {
15 }
16
17 int AsfPacket::init(uint_t timeshift)
18 {
19 uint8_t* memory = this->begin();
20 uint8_t* memory2 = memory + 1;
21
22 // parse packet header
23 //for (int i = 0 ; i < 15; i++) printf("%02x ", memory[i]); printf("\n");
24 length = 0xff;
25 if (memory[0] & 0x80)
26 {
27 if (memory[0] & 0x60)
28 {
29 AVM_WRITE("ASF reader", "WARNING: unknown error correction length 0x%x\n", memory[0]);
30 const uint8_t* me = memory + size() - 64;
31 do {
32 if (++memory >= me)
33 return -1;
34 } while (memory[0] != 0x82 || memory[1] != 0 || memory[2] != 0);
35 AVM_WRITE("ASF reader", "WARNING: resynced to 0x82\n");
36 }
37 int edl = memory[0] & 0x0f;
38 if (edl == 2)
39 {
40 if (memory[1] != 0 || memory[2] != 0)
41 {
42 AVM_WRITE("ASF reader", "WARNING: unexpected error correction for 0x%x\n", memory[0]);
43 return -1;
44 }
45 }
46 memory2 += edl; // skip Error Correction bytes (usually [0, 0])
47 }
48 else
49 memory2++;
50
51 length_flags = *memory2++;
52 property_flags = *memory2++;
53
54 size_t psize;
55 size_t padding;
56
57 #define DO_2BITS(bits, var, defval) \
58 switch (bits & 3) \
59 { \
60 case 3: var = avm_get_le32(memory2); memory2 += 4; break; \
61 case 2: var = avm_get_le16(memory2); memory2 += 2; break; \
62 case 1: var = memory2[0]; memory2++; break; \
63 default: var = defval; break; \
64 }
65
66 DO_2BITS(length_flags >> 5, psize, size());
67 DO_2BITS(length_flags >> 1, padding, 0); //sequence -> ignored
68 DO_2BITS(length_flags >> 3, padding, 0);
69
70 send_time = avm_get_le32(memory2);
71 if (timeshift > 0)
72 {
73 send_time -= timeshift;
74 avm_set_le32(memory2, send_time);
75 }
76 memory2 += 4;
77 duration = avm_get_le16(memory2); memory2 += 2;
78
79 //AVM_WRITE("ASF reader", "time %f len %d\n", send_time/1000.0, duration);
80 if (length_flags & 0x01)
81 {
82 segments = (uint8_t)(memory2[0] & 0x3f);
83 segsizetype = memory2[0];
84 memory2++;
85 }
86 else
87 {
88 segments = 1;
89 segsizetype = 0x80;
90 }
91 //printf("PSIZE %d PAD %d LEN %d\n", psize, padding, length);
92 length = memory2 - memory;
93 packet_length = (uint16_t)(psize - padding - length);
94 size_t offset = length;
95 // find all fragments in this packet
96 for (unsigned i = 0; i < segments; ++i)
97 {
98 int l = segment(memory, offset, timeshift);
99 if (l < 0)
100 {
101 segments = (uint8_t)i;
102 break;
103 }
104 offset += l;
105 if (offset > size())
106 {
107 AVM_WRITE("ASF reader", "WARNING: packet size overflow %" PRIsz " - %" PRIsz "\n", offset, size());
108 segments = (uint8_t)i;
109 break;
110 }
111 }
112
113 Debug AVM_WRITE("ASF reader", 2, "Created packet header for send_time %f, length %d, %d segments\n",
114 send_time/1000., packet_length, segments);
115
116 return 0;
117 }
118
119 int AsfPacket::segment(uint8_t* memory, size_t offset, uint_t timeshift)
120 {
121 uint8_t* memory2 = memory + offset;
122 uint8_t* timepos = 0;
123 AsfPacketFragment f;
124 f.keyframe = ((memory2[0] >> 7) & 0x1);
125 f.stream_id = memory2[0] & 0x7f;
126 memory2++;
127
128 uint32_t fragment_offset; // == present_time;
129 size_t replicated_length;
130
131 DO_2BITS(property_flags >> 4, f.seq_num, 0);
132 timepos = memory2; // remmeber for time modification
133 DO_2BITS(property_flags >> 2, fragment_offset, 0); // 0 is illegal
134 DO_2BITS(property_flags, replicated_length, 0);
135
136 Debug AVM_WRITE("ASF reader", 2, "StreamId: %3d flags: 0x%x seq: %d offset: %d\n", f.stream_id, length_flags, f.seq_num, fragment_offset);
137
138 if (replicated_length > 1)
139 {
140 // by the ASF spec it should contain at least these two elements
141 f.object_length = avm_get_le32(memory2);
142 f.object_start_time = avm_get_le32(memory2 + 4);
143 if (timeshift > 0)
144 {
145 f.object_start_time -= timeshift;
146 avm_set_le32(memory2 + 4, f.object_start_time);
147
148 }
149 if ((int)replicated_length > (packet_length - (memory2 - (memory + offset))))
150 return -1;
151 memory2 += replicated_length;
152 }
153 else
154 {
155 f.object_start_time = send_time;
156 f.object_length = 0;
157 if (replicated_length == 1) // compressed
158 memory2++; // skip presentation time delta
159 }
160
161 size_t plen;
162 if (length_flags & 0x01) // multiple fragment
163 {
164 // read packet length
165 DO_2BITS(segsizetype >> 6, plen, 0); // 0 is illegal
166 if ((int)plen > (packet_length - (memory2 - (memory + offset))))
167 return -1;
168 }
169 else // single fragment
170 // determine remaing packet length
171 plen = packet_length - (memory2 - (memory + offset));
172
173 //AVM_WRITE("ASF reader", "repli %d plen %d\n", replicated_length, plen);
174 if (replicated_length == 1) // compressed
175 {
176 f.fragment_offset = 0;
177
178 // fragment_offset becomes object_start_time
179 if (timeshift > 0)
180 {
181 fragment_offset -= timeshift;
182 avm_set_le32(timepos, fragment_offset);
183 }
184 f.object_start_time = fragment_offset;
185 const uint8_t* pend = memory2 + plen;
186 while (memory2 < pend)
187 {
188 f.object_length = f.data_length = *memory2++;
189 //printf("********* ------ %d\n", f.data_length);
190 f.pointer = memory2;
191 memory2 += f.data_length;
192 fragments.push_back(f);
193 }
194 }
195 else
196 {
197 f.fragment_offset = fragment_offset;
198 f.data_length = (uint32_t)plen;
199 //printf("____%d\n", plen);
200 f.pointer = memory2;
201 memory2 += f.data_length;
202 fragments.push_back(f);
203 }
204 //AVM_WRITE("ASF reader", 2, "Created segment header for stream %d, %d fragments\n",
205 // f.stream_id, fragments.size());
206
207 return (int) (memory2 - (memory + offset));
208 }
209
210 AVM_END_NAMESPACE;