← Back to branch summary

~ubuntu-branches/ubuntu/wily/xmms2/wily

« back to all changes in this revision

Viewing changes to src/plugins/asf/libasf/data.c

  • Committer: Bazaar Package Importer
  • Author(s): Benjamin Drung
  • Date: 2008-07-04 16:23:34 UTC
  • mfrom: (1.1.5 upstream) (6.1.1 lenny)
  • Revision ID: james.westby@ubuntu.com-20080704162334-b3esbkcapt8wbrk4
Tags: 0.5DrLecter-2ubuntu1
https://launchpad.net/bugs/241098
https://launchpad.net/bugs/212566
https://launchpad.net/bugs/222341
* Merge from debian unstable (LP: #241098), remaining changes:
  + debian/control:
    + Update Maintainer field
    + add lpia to xmms2-plugin-alsa supported architectures
    + Added liba52-0.7.4-dev to build depends
  + debian/rules: Added patch, patch-stamp and unpatch
  + changed 01_gcc4.3.patch:
    + src/include/xmmsclient/xmmsclient++/helpers.h: Added #include <climits>
* New upstream relase fixes LP: #212566, #222341

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/plugins/asf/libasf/data.c
51
51
        datap = data;
52
52
        packet->length = GETVALUE2b((flags >> 5) & 0x03, datap);
53
53
        datap += GETLEN2b((flags >> 5) & 0x03);
54
 
        /* sequence value is not used */
 
54
        /* sequence value should be never used anywhere */
55
55
        GETVALUE2b((flags >> 1) & 0x03, datap);
56
56
        datap += GETLEN2b((flags >> 1) & 0x03);
57
57
        packet->padding_length = GETVALUE2b((flags >> 3) & 0x03, datap);
99
99
        asf_payload_t pl;
100
100
        int i, tmp, skip;
101
101
 
102
 
        skip = 0;
103
 
        for (i=0; i<packet->payload_count; i++) {
 
102
        skip = 0, i = 0;
 
103
        while (i < packet->payload_count) {
104
104
                uint8_t pts_delta = 0;
105
105
                int compressed = 0;
106
106
 
107
 
                /* FIXME: mark keyframe? */
108
107
                pl.stream_number = data[skip] & 0x7f;
 
108
                pl.key_frame = !!(data[skip] & 0x80);
109
109
                skip++;
110
110
 
111
111
                tmp = asf_data_read_payload_data(&pl, flags, data + skip, datalen - skip);
167
167
                }
168
168
 
169
169
                if (compressed) {
170
 
                        int i, used = 0;
 
170
                        int payloads, start = skip, used = 0;
171
171
 
172
 
                        for (i=0; used < pl.datalen; i++)
173
 
                                used += 1 + data[skip + used];
 
172
                        /* count how many compressed payloads this payload includes */
 
173
                        for (payloads=0; used < pl.datalen; payloads++) {
 
174
                                used += 1 + data[start + used];
 
175
                        }
174
176
 
175
177
                        if (used != pl.datalen) {
176
178
                                /* invalid compressed data size */
177
179
                                return ASF_ERROR_INVALID_LENGTH;
178
180
                        }
179
181
 
180
 
                        packet->payload_count += i;
 
182
                        /* add additional payloads excluding the already allocated one */
 
183
                        packet->payload_count += payloads - 1;
181
184
                        if (packet->payload_count > packet->payloads_size) {
182
185
                                void *tempptr;
183
186
 
190
193
                                packet->payloads_size = packet->payload_count;
191
194
                        }
192
195
 
193
 
                        while (skip < datalen) {
 
196
                        while (skip < start + used) {
194
197
                                pl.datalen = data[skip];
195
198
                                skip++;
196
199
 
201
204
                                memcpy(&packet->payloads[i], &pl, sizeof(asf_payload_t));
202
205
                                i++;
203
206
                        }
204
 
                        i--;
205
207
                } else {
206
208
                        pl.data = data + skip;
207
209
                        memcpy(&packet->payloads[i], &pl, sizeof(asf_payload_t));
 
210
 
 
211
                        /* update the skipped data amount and payload index */
 
212
                        skip += pl.datalen;
 
213
                        i++;
208
214
                }
209
 
                skip += pl.datalen;
210
215
 
211
216
                debug_printf("payload(%d/%d) stream: %d, object: %d, offset: %d, pts: %d, datalen: %d",
212
217
                             i+1, packet->payload_count, pl.stream_number, pl.media_object_number,
232
237
        packet->payloads = NULL;
233
238
        packet->payloads_size = 0;
234
239
 
235
 
        packet->datalen = 0;
 
240
        packet->payload_data_len = 0;
236
241
        packet->payload_data = NULL;
237
242
        packet->payload_data_size = 0;
238
243
}
336
341
                payload_length_type = 0x02; /* not used */
337
342
        }
338
343
 
339
 
        packet->datalen = packet->length - read;
 
344
        packet->payload_data_len = packet->length - read;
340
345
 
341
346
        if (packet->payload_count > packet->payloads_size) {
342
347
                tmpptr = realloc(packet->payloads,
347
352
                packet->payloads = tmpptr;
348
353
                packet->payloads_size = packet->payload_count;
349
354
        }
350
 
        if (packet->datalen > packet->payload_data_size) {
 
355
        if (packet->payload_data_len > packet->payload_data_size) {
351
356
                tmpptr = realloc(packet->payload_data,
352
 
                                 packet->datalen);
 
357
                                 packet->payload_data_len);
353
358
                if (!tmpptr) {
354
359
                        return ASF_ERROR_OUTOFMEM;
355
360
                }
357
362
                packet->payload_data_size = packet->payload_count;
358
363
        }
359
364
 
360
 
        if ((tmp = asf_byteio_read(packet->payload_data, packet->datalen, stream)) < 0) {
 
365
        if ((tmp = asf_byteio_read(packet->payload_data, packet->payload_data_len, stream)) < 0) {
361
366
                return tmp;
362
367
        }
363
368
 
364
369
        tmp = asf_data_read_payloads(packet, file->preroll, packet_flags & 0x01,
365
370
                                     payload_length_type, packet_property,
366
371
                                     packet->payload_data,
367
 
                                     packet->datalen - packet->padding_length);
 
372
                                     packet->payload_data_len - packet->padding_length);
368
373
        if (tmp < 0) {
369
374
                return tmp;
370
375
        }