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