FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavformat/vividas.c
Date: 2024-05-03 15:42:48
Exec Total Coverage
Lines: 3 444 0.7%
Functions: 1 16 6.2%
Branches: 1 210 0.5%
Line Branch Exec Source
1 /*
2 * Vividas VIV format Demuxer
3 * Copyright (c) 2012 Krzysztof Klinikowski
4 * Copyright (c) 2010 Andrzej Szombierski
5 * based on vivparse Copyright (c) 2007 Måns Rullgård
6 *
7 * This file is part of FFmpeg.
8 *
9 * FFmpeg is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * FFmpeg is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with FFmpeg; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 */
23
24 /**
25 * @file
26 * @brief Vividas VIV (.viv) file demuxer
27 * @author Andrzej Szombierski [qq at kuku eu org] (2010-07)
28 * @sa http://wiki.multimedia.cx/index.php?title=Vividas_VIV
29 */
30
31 #include "libavutil/avassert.h"
32 #include "libavutil/intreadwrite.h"
33 #include "libavutil/mem.h"
34 #include "avio_internal.h"
35 #include "avformat.h"
36 #include "demux.h"
37 #include "internal.h"
38
39 #define MAX_AUDIO_SUBPACKETS 100
40
41 typedef struct VIV_SB_block {
42 int size, n_packets;
43 int64_t byte_offset;
44 int64_t packet_offset;
45 } VIV_SB_block;
46
47 typedef struct VIV_SB_entry {
48 int size, flag;
49 } VIV_SB_entry;
50
51 typedef struct VIV_AudioSubpacket {
52 int start, pcm_bytes;
53 } VIV_AudioSubpacket;
54
55 typedef struct VividasDemuxContext {
56 int n_sb_blocks;
57 VIV_SB_block *sb_blocks;
58 int num_audio;
59
60 uint32_t sb_key;
61 int64_t sb_offset;
62
63 int current_sb, current_sb_entry;
64 uint8_t *sb_buf;
65 AVIOContext *sb_pb;
66 int n_sb_entries;
67 VIV_SB_entry *sb_entries;
68
69 int n_audio_subpackets;
70 int current_audio_subpacket;
71
72 int64_t audio_sample;
73
74 VIV_AudioSubpacket audio_subpackets[MAX_AUDIO_SUBPACKETS];
75 } VividasDemuxContext;
76
77 7128 static int viv_probe(const AVProbeData *p)
78 {
79
1/2
✓ Branch 0 taken 7128 times.
✗ Branch 1 not taken.
 7128 if (memcmp(p->buf, "vividas03", 9))
80 7128 return 0;
81
82 ✗ return AVPROBE_SCORE_MAX;
83 }
84
85 static const uint8_t keybits[32] = {
86 20, 52, 111, 10, 27, 71, 142, 53,
87 82, 138, 1, 78, 86, 121, 183, 85,
88 105, 152, 39, 140, 172, 11, 64, 144,
89 155, 6, 71, 163, 186, 49, 126, 43,
90 };
91
92 ✗ static uint32_t decode_key(uint8_t *buf)
93 {
94 ✗ uint32_t key = 0;
95
96 ✗ for (int i = 0; i < 32; i++) {
97 ✗ unsigned p = keybits[i];
98 ✗ key |= ((buf[p] >> ((i*5+3)&7)) & 1u) << i;
99 }
100
101 ✗ return key;
102 }
103
104 ✗ static void put_v(uint8_t *p, unsigned v)
105 {
106 ✗ if (v>>28)
107 ✗ *p++ = ((v>>28)&0x7f)|0x80;
108 ✗ if (v>>21)
109 ✗ *p++ = ((v>>21)&0x7f)|0x80;
110 ✗ if (v>>14)
111 ✗ *p++ = ((v>>14)&0x7f)|0x80;
112 ✗ if (v>>7)
113 ✗ *p++ = ((v>>7)&0x7f)|0x80;
114 ✗ }
115
116 ✗ static unsigned recover_key(unsigned char sample[4], unsigned expected_size)
117 {
118 ✗ unsigned char plaintext[8] = { 'S', 'B' };
119
120 ✗ put_v(plaintext+2, expected_size);
121
122 ✗ return AV_RL32(sample) ^ AV_RL32(plaintext);
123 }
124
125 ✗ static void xor_block(void *p1, void *p2, unsigned size, int key, unsigned *key_ptr)
126 {
127 ✗ unsigned *d1 = p1;
128 ✗ unsigned *d2 = p2;
129 ✗ unsigned k = *key_ptr;
130
131 ✗ size >>= 2;
132
133 ✗ while (size > 0) {
134 ✗ *d2 = *d1 ^ (HAVE_BIGENDIAN ? av_bswap32(k) : k);
135 ✗ k += key;
136 ✗ d1++;
137 ✗ d2++;
138 ✗ size--;
139 }
140
141 ✗ *key_ptr = k;
142 ✗ }
143
144 ✗ static void decode_block(uint8_t *src, uint8_t *dest, unsigned size,
145 uint32_t key, uint32_t *key_ptr,
146 int align)
147 {
148 ✗ unsigned s = size;
149 char tmp[4];
150 int a2;
151
152 ✗ if (!size)
153 ✗ return;
154
155 ✗ align &= 3;
156 ✗ a2 = (4 - align) & 3;
157
158 ✗ if (align) {
159 ✗ uint32_t tmpkey = *key_ptr - key;
160 ✗ if (a2 > s) {
161 ✗ a2 = s;
162 ✗ avpriv_request_sample(NULL, "tiny aligned block");
163 }
164 ✗ memcpy(tmp + align, src, a2);
165 ✗ xor_block(tmp, tmp, 4, key, &tmpkey);
166 ✗ memcpy(dest, tmp + align, a2);
167 ✗ s -= a2;
168 }
169
170 ✗ if (s >= 4) {
171 ✗ xor_block(src + a2, dest + a2, s & ~3,
172 key, key_ptr);
173 ✗ s &= 3;
174 }
175
176 ✗ if (s) {
177 ✗ size -= s;
178 ✗ memcpy(tmp, src + size, s);
179 ✗ xor_block(&tmp, &tmp, 4, key, key_ptr);
180 ✗ memcpy(dest + size, tmp, s);
181 }
182 }
183
184 ✗ static uint32_t get_v(uint8_t *p, int len)
185 {
186 ✗ uint32_t v = 0;
187 ✗ const uint8_t *end = p + len;
188
189 do {
190 ✗ if (p >= end || v >= UINT_MAX / 128 - *p)
191 ✗ return v;
192 ✗ v <<= 7;
193 ✗ v += *p & 0x7f;
194 ✗ } while (*p++ & 0x80);
195
196 ✗ return v;
197 }
198
199 ✗ static uint8_t *read_vblock(AVIOContext *src, uint32_t *size,
200 uint32_t key, uint32_t *k2, int align)
201 {
202 uint8_t tmp[4];
203 uint8_t *buf;
204 unsigned n;
205
206 ✗ if (avio_read(src, tmp, 4) != 4)
207 ✗ return NULL;
208
209 ✗ decode_block(tmp, tmp, 4, key, k2, align);
210
211 ✗ n = get_v(tmp, 4);
212 ✗ if (n < 4)
213 ✗ return NULL;
214
215 ✗ buf = av_malloc(n);
216 ✗ if (!buf)
217 ✗ return NULL;
218
219 ✗ *size = n;
220 ✗ n -= 4;
221
222 ✗ memcpy(buf, tmp, 4);
223
224 ✗ if (avio_read(src, buf + 4, n) == n) {
225 ✗ decode_block(buf + 4, buf + 4, n, key, k2, align);
226 } else {
227 ✗ av_free(buf);
228 ✗ buf = NULL;
229 }
230
231 ✗ return buf;
232 }
233
234 ✗ static uint8_t *read_sb_block(AVIOContext *src, unsigned *size,
235 uint32_t *key, unsigned expected_size)
236 {
237 uint8_t *buf;
238 uint8_t ibuf[8], sbuf[8];
239 uint32_t k2;
240 unsigned n;
241
242 ✗ if (avio_read(src, ibuf, 8) < 8)
243 ✗ return NULL;
244
245 ✗ k2 = *key;
246 ✗ decode_block(ibuf, sbuf, 8, *key, &k2, 0);
247
248 ✗ n = get_v(sbuf+2, 6);
249
250 ✗ if (sbuf[0] != 'S' || sbuf[1] != 'B' || (expected_size>0 && n != expected_size)) {
251 ✗ uint32_t tmpkey = recover_key(ibuf, expected_size);
252 ✗ k2 = tmpkey;
253 ✗ decode_block(ibuf, sbuf, 8, tmpkey, &k2, 0);
254 ✗ n = get_v(sbuf+2, 6);
255 ✗ if (sbuf[0] != 'S' || sbuf[1] != 'B' || expected_size != n)
256 ✗ return NULL;
257 ✗ *key = tmpkey;
258 }
259
260 ✗ if (n < 8)
261 ✗ return NULL;
262
263 ✗ buf = av_malloc(n);
264 ✗ if (!buf)
265 ✗ return NULL;
266
267 ✗ memcpy(buf, sbuf, 8);
268
269 ✗ *size = n;
270 ✗ n -= 8;
271
272 ✗ if (avio_read(src, buf+8, n) != n) {
273 ✗ av_free(buf);
274 ✗ return NULL;
275 }
276
277 ✗ decode_block(buf + 8, buf + 8, n, *key, &k2, 0);
278
279 ✗ return buf;
280 }
281
282 ✗ static int track_header(VividasDemuxContext *viv, AVFormatContext *s,
283 const uint8_t *buf, int size)
284 {
285 int i, j, ret;
286 int64_t off;
287 int val_1;
288 int num_video;
289 FFIOContext pb0;
290 ✗ AVIOContext *const pb = &pb0.pub;
291
292 ✗ ffio_init_read_context(&pb0, buf, size);
293
294 ✗ ffio_read_varlen(pb); // track_header_len
295 ✗ avio_r8(pb); // '1'
296
297 ✗ val_1 = ffio_read_varlen(pb);
298
299 ✗ for (i=0;i<val_1;i++) {
300 ✗ int c = avio_r8(pb);
301 ✗ if (avio_feof(pb))
302 ✗ return AVERROR_EOF;
303 ✗ for (j=0;j<c;j++) {
304 ✗ if (avio_feof(pb))
305 ✗ return AVERROR_EOF;
306 ✗ avio_r8(pb); // val_3
307 ✗ avio_r8(pb); // val_4
308 }
309 }
310
311 ✗ avio_r8(pb); // num_streams
312
313 ✗ off = avio_tell(pb);
314 ✗ off += ffio_read_varlen(pb); // val_5
315
316 ✗ avio_r8(pb); // '2'
317 ✗ num_video = avio_r8(pb);
318
319 ✗ avio_seek(pb, off, SEEK_SET);
320 ✗ if (num_video != 1) {
321 ✗ av_log(s, AV_LOG_ERROR, "number of video tracks %d is not 1\n", num_video);
322 ✗ return AVERROR_PATCHWELCOME;
323 }
324
325 ✗ for (i = 0; i < num_video; i++) {
326 ✗ AVStream *st = avformat_new_stream(s, NULL);
327 int num, den;
328
329 ✗ if (!st)
330 ✗ return AVERROR(ENOMEM);
331
332 ✗ st->id = i;
333
334 ✗ st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
335 ✗ st->codecpar->codec_id = AV_CODEC_ID_VP6;
336
337 ✗ off = avio_tell(pb);
338 ✗ off += ffio_read_varlen(pb);
339 ✗ avio_r8(pb); // '3'
340 ✗ avio_r8(pb); // val_7
341 ✗ num = avio_rl32(pb); // frame_time
342 ✗ den = avio_rl32(pb); // time_base
343 ✗ avpriv_set_pts_info(st, 64, num, den);
344 ✗ st->nb_frames = avio_rl32(pb); // n frames
345 ✗ st->codecpar->width = avio_rl16(pb); // width
346 ✗ st->codecpar->height = avio_rl16(pb); // height
347 ✗ avio_r8(pb); // val_8
348 ✗ avio_rl32(pb); // val_9
349
350 ✗ avio_seek(pb, off, SEEK_SET);
351 }
352
353 ✗ off = avio_tell(pb);
354 ✗ off += ffio_read_varlen(pb); // val_10
355 ✗ avio_r8(pb); // '4'
356 ✗ viv->num_audio = avio_r8(pb);
357 ✗ avio_seek(pb, off, SEEK_SET);
358
359 ✗ if (viv->num_audio != 1)
360 ✗ av_log(s, AV_LOG_WARNING, "number of audio tracks %d is not 1\n", viv->num_audio);
361
362 ✗ for(i=0;i<viv->num_audio;i++) {
363 int q;
364 ✗ AVStream *st = avformat_new_stream(s, NULL);
365 ✗ if (!st)
366 ✗ return AVERROR(ENOMEM);
367
368 ✗ st->id = num_video + i;
369
370 ✗ st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
371 ✗ st->codecpar->codec_id = AV_CODEC_ID_VORBIS;
372
373 ✗ off = avio_tell(pb);
374 ✗ off += ffio_read_varlen(pb); // length
375 ✗ avio_r8(pb); // '5'
376 ✗ avio_r8(pb); //codec_id
377 ✗ avio_rl16(pb); //codec_subid
378 ✗ st->codecpar->ch_layout.nb_channels = avio_rl16(pb); // channels
379 ✗ st->codecpar->sample_rate = avio_rl32(pb); // sample_rate
380 ✗ if (st->codecpar->sample_rate <= 0 || st->codecpar->ch_layout.nb_channels <= 0)
381 ✗ return AVERROR_INVALIDDATA;
382 ✗ avio_seek(pb, 10, SEEK_CUR); // data_1
383 ✗ q = avio_r8(pb);
384 ✗ avio_seek(pb, q, SEEK_CUR); // data_2
385 ✗ avio_r8(pb); // zeropad
386
387 ✗ if (avio_tell(pb) < off) {
388 int num_data;
389 ✗ int xd_size = 1;
390 int data_len[256];
391 ✗ int offset = 1;
392 uint8_t *p;
393 ✗ ffio_read_varlen(pb); // val_13
394 ✗ avio_r8(pb); // '19'
395 ✗ ffio_read_varlen(pb); // len_3
396 ✗ num_data = avio_r8(pb);
397 ✗ for (j = 0; j < num_data; j++) {
398 ✗ int64_t len = ffio_read_varlen(pb);
399 ✗ if (len < 0 || len > INT_MAX/2 - xd_size) {
400 ✗ return AVERROR_INVALIDDATA;
401 }
402 ✗ data_len[j] = len;
403 ✗ xd_size += len + 1 + len/255;
404 }
405
406 ✗ ret = ff_alloc_extradata(st->codecpar, xd_size);
407 ✗ if (ret < 0)
408 ✗ return ret;
409
410 ✗ p = st->codecpar->extradata;
411 ✗ p[0] = 2;
412
413 ✗ for (j = 0; j < num_data - 1; j++) {
414 ✗ unsigned delta = av_xiphlacing(&p[offset], data_len[j]);
415 ✗ av_assert0(delta <= xd_size - offset);
416 ✗ offset += delta;
417 }
418
419 ✗ for (j = 0; j < num_data; j++) {
420 ✗ int ret = avio_read(pb, &p[offset], data_len[j]);
421 ✗ if (ret < data_len[j]) {
422 ✗ st->codecpar->extradata_size = 0;
423 ✗ av_freep(&st->codecpar->extradata);
424 ✗ break;
425 }
426 ✗ av_assert0(data_len[j] <= xd_size - offset);
427 ✗ offset += data_len[j];
428 }
429
430 ✗ if (offset < st->codecpar->extradata_size)
431 ✗ st->codecpar->extradata_size = offset;
432 }
433 }
434
435 ✗ return 0;
436 }
437
438 ✗ static int track_index(VividasDemuxContext *viv, AVFormatContext *s,
439 const uint8_t *buf, unsigned size)
440 {
441 int64_t off;
442 int64_t poff;
443 ✗ int maxnp=0;
444 FFIOContext pb0;
445 ✗ AVIOContext *const pb = &pb0.pub;
446 int i;
447 ✗ int64_t filesize = avio_size(s->pb);
448 uint64_t n_sb_blocks_tmp;
449
450 ✗ ffio_init_read_context(&pb0, buf, size);
451
452 ✗ ffio_read_varlen(pb); // track_index_len
453 ✗ avio_r8(pb); // 'c'
454 ✗ n_sb_blocks_tmp = ffio_read_varlen(pb);
455 ✗ if (n_sb_blocks_tmp > size / 2)
456 ✗ return AVERROR_INVALIDDATA;
457 ✗ viv->sb_blocks = av_calloc(n_sb_blocks_tmp, sizeof(*viv->sb_blocks));
458 ✗ if (!viv->sb_blocks) {
459 ✗ return AVERROR(ENOMEM);
460 }
461 ✗ viv->n_sb_blocks = n_sb_blocks_tmp;
462
463 ✗ off = 0;
464 ✗ poff = 0;
465
466 ✗ for (i = 0; i < viv->n_sb_blocks; i++) {
467 ✗ uint64_t size_tmp = ffio_read_varlen(pb);
468 ✗ uint64_t n_packets_tmp = ffio_read_varlen(pb);
469
470 ✗ if (size_tmp > INT_MAX || n_packets_tmp > INT_MAX)
471 ✗ return AVERROR_INVALIDDATA;
472
473 ✗ viv->sb_blocks[i].byte_offset = off;
474 ✗ viv->sb_blocks[i].packet_offset = poff;
475
476 ✗ viv->sb_blocks[i].size = size_tmp;
477 ✗ viv->sb_blocks[i].n_packets = n_packets_tmp;
478
479 ✗ off += viv->sb_blocks[i].size;
480 ✗ poff += viv->sb_blocks[i].n_packets;
481
482 ✗ if (maxnp < viv->sb_blocks[i].n_packets)
483 ✗ maxnp = viv->sb_blocks[i].n_packets;
484 }
485
486 ✗ if (filesize > 0 && poff > filesize)
487 ✗ return AVERROR_INVALIDDATA;
488
489 ✗ viv->sb_entries = av_calloc(maxnp, sizeof(VIV_SB_entry));
490 ✗ if (!viv->sb_entries)
491 ✗ return AVERROR(ENOMEM);
492
493 ✗ return 0;
494 }
495
496 ✗ static void load_sb_block(AVFormatContext *s, VividasDemuxContext *viv, unsigned expected_size)
497 {
498 ✗ uint32_t size = 0;
499 int i;
500 ✗ AVIOContext *pb = 0;
501
502 ✗ if (viv->sb_pb) {
503 ✗ av_free(viv->sb_pb);
504 ✗ viv->sb_pb = NULL;
505 }
506
507 ✗ if (viv->sb_buf)
508 ✗ av_free(viv->sb_buf);
509
510 ✗ viv->sb_buf = read_sb_block(s->pb, &size, &viv->sb_key, expected_size);
511 ✗ if (!viv->sb_buf) {
512 ✗ return;
513 }
514
515 ✗ pb = avio_alloc_context(viv->sb_buf, size, 0, NULL, NULL, NULL, NULL);
516 ✗ if (!pb)
517 ✗ return;
518
519 ✗ viv->sb_pb = pb;
520
521 ✗ avio_r8(pb); // 'S'
522 ✗ avio_r8(pb); // 'B'
523 ✗ ffio_read_varlen(pb); // size
524 ✗ avio_r8(pb); // junk
525 ✗ ffio_read_varlen(pb); // first packet
526
527 ✗ viv->n_sb_entries = viv->sb_blocks[viv->current_sb].n_packets;
528
529 ✗ for (i = 0; i < viv->n_sb_entries; i++) {
530 ✗ viv->sb_entries[i].size = ffio_read_varlen(pb);
531 ✗ viv->sb_entries[i].flag = avio_r8(pb);
532 }
533
534 ✗ ffio_read_varlen(pb);
535 ✗ avio_r8(pb);
536
537 ✗ viv->current_sb_entry = 0;
538 }
539
540 ✗ static int viv_read_header(AVFormatContext *s)
541 {
542 ✗ VividasDemuxContext *viv = s->priv_data;
543 ✗ AVIOContext *pb = s->pb;
544 int64_t header_end;
545 int num_tracks;
546 uint32_t key, k2;
547 uint32_t v;
548 uint8_t keybuffer[187];
549 ✗ uint32_t b22_size = 0;
550 ✗ uint32_t b22_key = 0;
551 ✗ uint8_t *buf = 0;
552 int ret;
553
554 ✗ avio_skip(pb, 9);
555
556 ✗ header_end = avio_tell(pb);
557
558 ✗ header_end += ffio_read_varlen(pb);
559
560 ✗ num_tracks = avio_r8(pb);
561
562 ✗ if (num_tracks != 1) {
563 ✗ av_log(s, AV_LOG_ERROR, "number of tracks %d is not 1\n", num_tracks);
564 ✗ return AVERROR(EINVAL);
565 }
566
567 ✗ v = avio_r8(pb);
568 ✗ avio_seek(pb, v, SEEK_CUR);
569
570 ✗ avio_read(pb, keybuffer, 187);
571 ✗ key = decode_key(keybuffer);
572 ✗ viv->sb_key = key;
573
574 ✗ avio_rl32(pb);
575
576 ✗ for (;;) {
577 ✗ int64_t here = avio_tell(pb);
578 int block_len, block_type;
579
580 ✗ if (here >= header_end)
581 ✗ break;
582
583 ✗ block_len = ffio_read_varlen(pb);
584 ✗ if (avio_feof(pb) || block_len <= 0)
585 ✗ return AVERROR_INVALIDDATA;
586
587 ✗ block_type = avio_r8(pb);
588
589 ✗ if (block_type == 22) {
590 ✗ avio_read(pb, keybuffer, 187);
591 ✗ b22_key = decode_key(keybuffer);
592 ✗ b22_size = avio_rl32(pb);
593 }
594
595 ✗ avio_seek(pb, here + block_len, SEEK_SET);
596 }
597
598 ✗ if (b22_size) {
599 ✗ k2 = b22_key;
600 ✗ buf = read_vblock(pb, &v, b22_key, &k2, 0);
601 ✗ if (!buf)
602 ✗ return AVERROR(EIO);
603
604 ✗ av_free(buf);
605 }
606
607 ✗ k2 = key;
608 ✗ buf = read_vblock(pb, &v, key, &k2, 0);
609 ✗ if (!buf)
610 ✗ return AVERROR(EIO);
611 ✗ ret = track_header(viv, s, buf, v);
612 ✗ av_free(buf);
613 ✗ if (ret < 0)
614 ✗ return ret;
615
616 ✗ buf = read_vblock(pb, &v, key, &k2, v);
617 ✗ if (!buf)
618 ✗ return AVERROR(EIO);
619 ✗ ret = track_index(viv, s, buf, v);
620 ✗ av_free(buf);
621 ✗ if (ret < 0)
622 ✗ return ret;
623
624 ✗ viv->sb_offset = avio_tell(pb);
625 ✗ if (viv->n_sb_blocks > 0) {
626 ✗ viv->current_sb = 0;
627 ✗ load_sb_block(s, viv, viv->sb_blocks[0].size);
628 } else {
629 ✗ viv->current_sb = -1;
630 }
631
632 ✗ return 0;
633 }
634
635 ✗ static int viv_read_packet(AVFormatContext *s,
636 AVPacket *pkt)
637 {
638 ✗ VividasDemuxContext *viv = s->priv_data;
639 AVIOContext *pb;
640 int64_t off;
641 int ret;
642
643 ✗ if (!viv->sb_pb)
644 ✗ return AVERROR(EIO);
645 ✗ if (avio_feof(viv->sb_pb))
646 ✗ return AVERROR_EOF;
647
648 ✗ if (viv->current_audio_subpacket < viv->n_audio_subpackets) {
649 AVStream *astream;
650 ✗ int size = viv->audio_subpackets[viv->current_audio_subpacket+1].start - viv->audio_subpackets[viv->current_audio_subpacket].start;
651
652 ✗ pb = viv->sb_pb;
653 ✗ ret = av_get_packet(pb, pkt, size);
654 ✗ if (ret < 0)
655 ✗ return ret;
656 ✗ pkt->pos += viv->sb_offset + viv->sb_blocks[viv->current_sb].byte_offset;
657
658 ✗ pkt->stream_index = 1;
659 ✗ astream = s->streams[pkt->stream_index];
660
661 ✗ pkt->pts = av_rescale_q(viv->audio_sample, av_make_q(1, astream->codecpar->sample_rate), astream->time_base);
662 ✗ viv->audio_sample += viv->audio_subpackets[viv->current_audio_subpacket].pcm_bytes / 2 /
663 ✗ astream->codecpar->ch_layout.nb_channels;
664 ✗ pkt->flags |= AV_PKT_FLAG_KEY;
665 ✗ viv->current_audio_subpacket++;
666 ✗ return 0;
667 }
668
669 ✗ if (viv->current_sb_entry >= viv->n_sb_entries) {
670 ✗ if (viv->current_sb+1 >= viv->n_sb_blocks)
671 ✗ return AVERROR(EIO);
672 ✗ viv->current_sb++;
673
674 ✗ load_sb_block(s, viv, 0);
675 ✗ viv->current_sb_entry = 0;
676 }
677
678 ✗ pb = viv->sb_pb;
679 ✗ if (!pb)
680 ✗ return AVERROR(EIO);
681 ✗ off = avio_tell(pb);
682
683 ✗ if (viv->current_sb_entry >= viv->n_sb_entries)
684 ✗ return AVERROR_INVALIDDATA;
685
686 ✗ off += viv->sb_entries[viv->current_sb_entry].size;
687
688 ✗ if (viv->sb_entries[viv->current_sb_entry].flag == 0) {
689 ✗ uint64_t v_size = ffio_read_varlen(pb);
690 ✗ int last = 0, last_start;
691
692 ✗ if (!viv->num_audio)
693 ✗ return AVERROR_INVALIDDATA;
694
695 ✗ ffio_read_varlen(pb);
696 ✗ if (v_size > INT_MAX || !v_size)
697 ✗ return AVERROR_INVALIDDATA;
698 ✗ ret = av_get_packet(pb, pkt, v_size);
699 ✗ if (ret < 0)
700 ✗ return ret;
701 ✗ pkt->pos += viv->sb_offset + viv->sb_blocks[viv->current_sb].byte_offset;
702
703 ✗ pkt->pts = viv->sb_blocks[viv->current_sb].packet_offset + viv->current_sb_entry;
704 ✗ pkt->flags |= (pkt->data[0]&0x80)?0:AV_PKT_FLAG_KEY;
705 ✗ pkt->stream_index = 0;
706
707 ✗ for (int i = 0; i < MAX_AUDIO_SUBPACKETS - 1; i++) {
708 int start, pcm_bytes;
709 ✗ start = ffio_read_varlen(pb);
710 ✗ pcm_bytes = ffio_read_varlen(pb);
711
712 ✗ if (i > 0 && start == 0)
713 ✗ break;
714 ✗ if (start < last)
715 ✗ return AVERROR_INVALIDDATA;
716
717 ✗ viv->n_audio_subpackets = i + 1;
718 ✗ last =
719 ✗ viv->audio_subpackets[i].start = start;
720 ✗ viv->audio_subpackets[i].pcm_bytes = pcm_bytes;
721 }
722 ✗ last_start =
723 ✗ viv->audio_subpackets[viv->n_audio_subpackets].start = (int)(off - avio_tell(pb));
724 ✗ if (last_start < last)
725 ✗ return AVERROR_INVALIDDATA;
726 ✗ viv->current_audio_subpacket = 0;
727
728 } else {
729 ✗ uint64_t v_size = ffio_read_varlen(pb);
730
731 ✗ if (v_size > INT_MAX || !v_size)
732 ✗ return AVERROR_INVALIDDATA;
733 ✗ ret = av_get_packet(pb, pkt, v_size);
734 ✗ if (ret < 0)
735 ✗ return ret;
736 ✗ pkt->pos += viv->sb_offset + viv->sb_blocks[viv->current_sb].byte_offset;
737 ✗ pkt->pts = viv->sb_blocks[viv->current_sb].packet_offset + viv->current_sb_entry;
738 ✗ pkt->flags |= (pkt->data[0] & 0x80) ? 0 : AV_PKT_FLAG_KEY;
739 ✗ pkt->stream_index = 0;
740 }
741
742 ✗ viv->current_sb_entry++;
743
744 ✗ return 0;
745 }
746
747 ✗ static int viv_read_close(AVFormatContext *s)
748 {
749 ✗ VividasDemuxContext *viv = s->priv_data;
750
751 ✗ av_freep(&viv->sb_pb);
752 ✗ av_freep(&viv->sb_buf);
753 ✗ av_freep(&viv->sb_blocks);
754 ✗ av_freep(&viv->sb_entries);
755
756 ✗ return 0;
757 }
758
759 ✗ static int viv_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
760 {
761 ✗ VividasDemuxContext *viv = s->priv_data;
762 int64_t frame;
763
764 ✗ if (stream_index == 0)
765 ✗ frame = timestamp;
766 else
767 ✗ frame = av_rescale_q(timestamp, s->streams[0]->time_base, s->streams[stream_index]->time_base);
768
769 ✗ for (int i = 0; i < viv->n_sb_blocks; i++) {
770 ✗ if (frame >= viv->sb_blocks[i].packet_offset && frame < viv->sb_blocks[i].packet_offset + viv->sb_blocks[i].n_packets) {
771 ✗ viv->current_sb = i;
772 // seek to ith sb block
773 ✗ avio_seek(s->pb, viv->sb_offset + viv->sb_blocks[i].byte_offset, SEEK_SET);
774 // load the block
775 ✗ load_sb_block(s, viv, 0);
776 ✗ if (viv->num_audio) {
777 ✗ const AVCodecParameters *par = s->streams[1]->codecpar;
778 // flush audio packet queue
779 ✗ viv->current_audio_subpacket = 0;
780 ✗ viv->n_audio_subpackets = 0;
781 // most problematic part: guess audio offset
782 ✗ viv->audio_sample = av_rescale_q(viv->sb_blocks[i].packet_offset,
783 ✗ av_make_q(par->sample_rate, 1),
784 ✗ av_inv_q(s->streams[0]->time_base));
785 // hand-tuned 1.s a/v offset
786 ✗ viv->audio_sample += par->sample_rate;
787 }
788 ✗ viv->current_sb_entry = 0;
789 ✗ return 1;
790 }
791 }
792 ✗ return 0;
793 }
794
795 const FFInputFormat ff_vividas_demuxer = {
796 .p.name = "vividas",
797 .p.long_name = NULL_IF_CONFIG_SMALL("Vividas VIV"),
798 .priv_data_size = sizeof(VividasDemuxContext),
799 .flags_internal = FF_INFMT_FLAG_INIT_CLEANUP,
800 .read_probe = viv_probe,
801 .read_header = viv_read_header,
802 .read_packet = viv_read_packet,
803 .read_close = viv_read_close,
804 .read_seek = viv_read_seek,
805 };
806