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