FFmpeg
vividas.c
Go to the documentation of this file.
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 "avio_internal.h"
34 #include "avformat.h"
35 #include "internal.h"
36 
37 #define MAX_AUDIO_SUBPACKETS 100
38 
39 typedef struct VIV_SB_block {
41  int64_t byte_offset;
42  int64_t packet_offset;
43 } VIV_SB_block;
44 
45 typedef struct VIV_SB_entry {
46  int size, flag;
47 } VIV_SB_entry;
48 
49 typedef struct VIV_AudioSubpacket {
52 
53 typedef struct VividasDemuxContext {
56  int num_audio;
57 
58  uint32_t sb_key;
59  int64_t sb_offset;
60 
62  uint8_t *sb_buf;
66 
69 
70  int64_t audio_sample;
71 
74 
75 static int viv_probe(const AVProbeData *p)
76 {
77  if (memcmp(p->buf, "vividas03", 9))
78  return 0;
79 
80  return AVPROBE_SCORE_MAX;
81 }
82 
83 static const uint8_t keybits[32] = {
84  20, 52, 111, 10, 27, 71, 142, 53,
85  82, 138, 1, 78, 86, 121, 183, 85,
86 105, 152, 39, 140, 172, 11, 64, 144,
87 155, 6, 71, 163, 186, 49, 126, 43,
88 };
89 
90 static uint32_t decode_key(uint8_t *buf)
91 {
92  uint32_t key = 0;
93 
94  for (int i = 0; i < 32; i++) {
95  unsigned p = keybits[i];
96  key |= ((buf[p] >> ((i*5+3)&7)) & 1u) << i;
97  }
98 
99  return key;
100 }
101 
102 static void put_v(uint8_t *p, unsigned v)
103 {
104  if (v>>28)
105  *p++ = ((v>>28)&0x7f)|0x80;
106  if (v>>21)
107  *p++ = ((v>>21)&0x7f)|0x80;
108  if (v>>14)
109  *p++ = ((v>>14)&0x7f)|0x80;
110  if (v>>7)
111  *p++ = ((v>>7)&0x7f)|0x80;
112 }
113 
114 static unsigned recover_key(unsigned char sample[4], unsigned expected_size)
115 {
116  unsigned char plaintext[8] = { 'S', 'B' };
117 
118  put_v(plaintext+2, expected_size);
119 
120  return AV_RL32(sample) ^ AV_RL32(plaintext);
121 }
122 
123 static void xor_block(void *p1, void *p2, unsigned size, int key, unsigned *key_ptr)
124 {
125  unsigned *d1 = p1;
126  unsigned *d2 = p2;
127  unsigned k = *key_ptr;
128 
129  size >>= 2;
130 
131  while (size > 0) {
132  *d2 = *d1 ^ (HAVE_BIGENDIAN ? av_bswap32(k) : k);
133  k += key;
134  d1++;
135  d2++;
136  size--;
137  }
138 
139  *key_ptr = k;
140 }
141 
142 static void decode_block(uint8_t *src, uint8_t *dest, unsigned size,
143  uint32_t key, uint32_t *key_ptr,
144  int align)
145 {
146  unsigned s = size;
147  char tmp[4];
148  int a2;
149 
150  if (!size)
151  return;
152 
153  align &= 3;
154  a2 = (4 - align) & 3;
155 
156  if (align) {
157  uint32_t tmpkey = *key_ptr - key;
158  if (a2 > s) {
159  a2 = s;
160  avpriv_request_sample(NULL, "tiny aligned block");
161  }
162  memcpy(tmp + align, src, a2);
163  xor_block(tmp, tmp, 4, key, &tmpkey);
164  memcpy(dest, tmp + align, a2);
165  s -= a2;
166  }
167 
168  if (s >= 4) {
169  xor_block(src + a2, dest + a2, s & ~3,
170  key, key_ptr);
171  s &= 3;
172  }
173 
174  if (s) {
175  size -= s;
176  memcpy(tmp, src + size, s);
177  xor_block(&tmp, &tmp, 4, key, key_ptr);
178  memcpy(dest + size, tmp, s);
179  }
180 }
181 
182 static uint32_t get_v(uint8_t *p, int len)
183 {
184  uint32_t v = 0;
185  const uint8_t *end = p + len;
186 
187  do {
188  if (p >= end || v >= UINT_MAX / 128 - *p)
189  return v;
190  v <<= 7;
191  v += *p & 0x7f;
192  } while (*p++ & 0x80);
193 
194  return v;
195 }
196 
197 static uint8_t *read_vblock(AVIOContext *src, uint32_t *size,
198  uint32_t key, uint32_t *k2, int align)
199 {
200  uint8_t tmp[4];
201  uint8_t *buf;
202  unsigned n;
203 
204  if (avio_read(src, tmp, 4) != 4)
205  return NULL;
206 
207  decode_block(tmp, tmp, 4, key, k2, align);
208 
209  n = get_v(tmp, 4);
210  if (n < 4)
211  return NULL;
212 
213  buf = av_malloc(n);
214  if (!buf)
215  return NULL;
216 
217  *size = n;
218  n -= 4;
219 
220  memcpy(buf, tmp, 4);
221 
222  if (avio_read(src, buf + 4, n) == n) {
223  decode_block(buf + 4, buf + 4, n, key, k2, align);
224  } else {
225  av_free(buf);
226  buf = NULL;
227  }
228 
229  return buf;
230 }
231 
232 static uint8_t *read_sb_block(AVIOContext *src, unsigned *size,
233  uint32_t *key, unsigned expected_size)
234 {
235  uint8_t *buf;
236  uint8_t ibuf[8], sbuf[8];
237  uint32_t k2;
238  unsigned n;
239 
240  if (avio_read(src, ibuf, 8) < 8)
241  return NULL;
242 
243  k2 = *key;
244  decode_block(ibuf, sbuf, 8, *key, &k2, 0);
245 
246  n = get_v(sbuf+2, 6);
247 
248  if (sbuf[0] != 'S' || sbuf[1] != 'B' || (expected_size>0 && n != expected_size)) {
249  uint32_t tmpkey = recover_key(ibuf, expected_size);
250  k2 = tmpkey;
251  decode_block(ibuf, sbuf, 8, tmpkey, &k2, 0);
252  n = get_v(sbuf+2, 6);
253  if (sbuf[0] != 'S' || sbuf[1] != 'B' || expected_size != n)
254  return NULL;
255  *key = tmpkey;
256  }
257 
258  if (n < 8)
259  return NULL;
260 
261  buf = av_malloc(n);
262  if (!buf)
263  return NULL;
264 
265  memcpy(buf, sbuf, 8);
266 
267  *size = n;
268  n -= 8;
269 
270  if (avio_read(src, buf+8, n) != n) {
271  av_free(buf);
272  return NULL;
273  }
274 
275  decode_block(buf + 8, buf + 8, n, *key, &k2, 0);
276 
277  return buf;
278 }
279 
281  const uint8_t *buf, int size)
282 {
283  int i, j, ret;
284  int64_t off;
285  int val_1;
286  int num_video;
287  FFIOContext pb0;
288  AVIOContext *const pb = &pb0.pub;
289 
290  ffio_init_read_context(&pb0, buf, size);
291 
292  ffio_read_varlen(pb); // track_header_len
293  avio_r8(pb); // '1'
294 
295  val_1 = ffio_read_varlen(pb);
296 
297  for (i=0;i<val_1;i++) {
298  int c = avio_r8(pb);
299  if (avio_feof(pb))
300  return AVERROR_EOF;
301  for (j=0;j<c;j++) {
302  if (avio_feof(pb))
303  return AVERROR_EOF;
304  avio_r8(pb); // val_3
305  avio_r8(pb); // val_4
306  }
307  }
308 
309  avio_r8(pb); // num_streams
310 
311  off = avio_tell(pb);
312  off += ffio_read_varlen(pb); // val_5
313 
314  avio_r8(pb); // '2'
315  num_video = avio_r8(pb);
316 
317  avio_seek(pb, off, SEEK_SET);
318  if (num_video != 1) {
319  av_log(s, AV_LOG_ERROR, "number of video tracks %d is not 1\n", num_video);
320  return AVERROR_PATCHWELCOME;
321  }
322 
323  for (i = 0; i < num_video; i++) {
325  int num, den;
326 
327  if (!st)
328  return AVERROR(ENOMEM);
329 
330  st->id = i;
331 
334 
335  off = avio_tell(pb);
336  off += ffio_read_varlen(pb);
337  avio_r8(pb); // '3'
338  avio_r8(pb); // val_7
339  num = avio_rl32(pb); // frame_time
340  den = avio_rl32(pb); // time_base
341  avpriv_set_pts_info(st, 64, num, den);
342  st->nb_frames = avio_rl32(pb); // n frames
343  st->codecpar->width = avio_rl16(pb); // width
344  st->codecpar->height = avio_rl16(pb); // height
345  avio_r8(pb); // val_8
346  avio_rl32(pb); // val_9
347 
348  avio_seek(pb, off, SEEK_SET);
349  }
350 
351  off = avio_tell(pb);
352  off += ffio_read_varlen(pb); // val_10
353  avio_r8(pb); // '4'
354  viv->num_audio = avio_r8(pb);
355  avio_seek(pb, off, SEEK_SET);
356 
357  if (viv->num_audio != 1)
358  av_log(s, AV_LOG_WARNING, "number of audio tracks %d is not 1\n", viv->num_audio);
359 
360  for(i=0;i<viv->num_audio;i++) {
361  int q;
363  if (!st)
364  return AVERROR(ENOMEM);
365 
366  st->id = num_video + i;
367 
370 
371  off = avio_tell(pb);
372  off += ffio_read_varlen(pb); // length
373  avio_r8(pb); // '5'
374  avio_r8(pb); //codec_id
375  avio_rl16(pb); //codec_subid
376  st->codecpar->ch_layout.nb_channels = avio_rl16(pb); // channels
377  st->codecpar->sample_rate = avio_rl32(pb); // sample_rate
378  if (st->codecpar->sample_rate <= 0 || st->codecpar->ch_layout.nb_channels <= 0)
379  return AVERROR_INVALIDDATA;
380  avio_seek(pb, 10, SEEK_CUR); // data_1
381  q = avio_r8(pb);
382  avio_seek(pb, q, SEEK_CUR); // data_2
383  avio_r8(pb); // zeropad
384 
385  if (avio_tell(pb) < off) {
386  int num_data;
387  int xd_size = 1;
388  int data_len[256];
389  int offset = 1;
390  uint8_t *p;
391  ffio_read_varlen(pb); // val_13
392  avio_r8(pb); // '19'
393  ffio_read_varlen(pb); // len_3
394  num_data = avio_r8(pb);
395  for (j = 0; j < num_data; j++) {
396  int64_t len = ffio_read_varlen(pb);
397  if (len < 0 || len > INT_MAX/2 - xd_size) {
398  return AVERROR_INVALIDDATA;
399  }
400  data_len[j] = len;
401  xd_size += len + 1 + len/255;
402  }
403 
404  ret = ff_alloc_extradata(st->codecpar, xd_size);
405  if (ret < 0)
406  return ret;
407 
408  p = st->codecpar->extradata;
409  p[0] = 2;
410 
411  for (j = 0; j < num_data - 1; j++) {
412  unsigned delta = av_xiphlacing(&p[offset], data_len[j]);
413  av_assert0(delta <= xd_size - offset);
414  offset += delta;
415  }
416 
417  for (j = 0; j < num_data; j++) {
418  int ret = avio_read(pb, &p[offset], data_len[j]);
419  if (ret < data_len[j]) {
420  st->codecpar->extradata_size = 0;
421  av_freep(&st->codecpar->extradata);
422  break;
423  }
424  av_assert0(data_len[j] <= xd_size - offset);
425  offset += data_len[j];
426  }
427 
428  if (offset < st->codecpar->extradata_size)
430  }
431  }
432 
433  return 0;
434 }
435 
437  const uint8_t *buf, unsigned size)
438 {
439  int64_t off;
440  int64_t poff;
441  int maxnp=0;
442  FFIOContext pb0;
443  AVIOContext *const pb = &pb0.pub;
444  int i;
445  int64_t filesize = avio_size(s->pb);
446  uint64_t n_sb_blocks_tmp;
447 
448  ffio_init_read_context(&pb0, buf, size);
449 
450  ffio_read_varlen(pb); // track_index_len
451  avio_r8(pb); // 'c'
452  n_sb_blocks_tmp = ffio_read_varlen(pb);
453  if (n_sb_blocks_tmp > size / 2)
454  return AVERROR_INVALIDDATA;
455  viv->sb_blocks = av_calloc(n_sb_blocks_tmp, sizeof(*viv->sb_blocks));
456  if (!viv->sb_blocks) {
457  return AVERROR(ENOMEM);
458  }
459  viv->n_sb_blocks = n_sb_blocks_tmp;
460 
461  off = 0;
462  poff = 0;
463 
464  for (i = 0; i < viv->n_sb_blocks; i++) {
465  uint64_t size_tmp = ffio_read_varlen(pb);
466  uint64_t n_packets_tmp = ffio_read_varlen(pb);
467 
468  if (size_tmp > INT_MAX || n_packets_tmp > INT_MAX)
469  return AVERROR_INVALIDDATA;
470 
471  viv->sb_blocks[i].byte_offset = off;
472  viv->sb_blocks[i].packet_offset = poff;
473 
474  viv->sb_blocks[i].size = size_tmp;
475  viv->sb_blocks[i].n_packets = n_packets_tmp;
476 
477  off += viv->sb_blocks[i].size;
478  poff += viv->sb_blocks[i].n_packets;
479 
480  if (maxnp < viv->sb_blocks[i].n_packets)
481  maxnp = viv->sb_blocks[i].n_packets;
482  }
483 
484  if (filesize > 0 && poff > filesize)
485  return AVERROR_INVALIDDATA;
486 
487  viv->sb_entries = av_calloc(maxnp, sizeof(VIV_SB_entry));
488  if (!viv->sb_entries)
489  return AVERROR(ENOMEM);
490 
491  return 0;
492 }
493 
494 static void load_sb_block(AVFormatContext *s, VividasDemuxContext *viv, unsigned expected_size)
495 {
496  uint32_t size = 0;
497  int i;
498  AVIOContext *pb = 0;
499 
500  if (viv->sb_pb) {
501  av_free(viv->sb_pb);
502  viv->sb_pb = NULL;
503  }
504 
505  if (viv->sb_buf)
506  av_free(viv->sb_buf);
507 
508  viv->sb_buf = read_sb_block(s->pb, &size, &viv->sb_key, expected_size);
509  if (!viv->sb_buf) {
510  return;
511  }
512 
513  pb = avio_alloc_context(viv->sb_buf, size, 0, NULL, NULL, NULL, NULL);
514  if (!pb)
515  return;
516 
517  viv->sb_pb = pb;
518 
519  avio_r8(pb); // 'S'
520  avio_r8(pb); // 'B'
521  ffio_read_varlen(pb); // size
522  avio_r8(pb); // junk
523  ffio_read_varlen(pb); // first packet
524 
525  viv->n_sb_entries = viv->sb_blocks[viv->current_sb].n_packets;
526 
527  for (i = 0; i < viv->n_sb_entries; i++) {
528  viv->sb_entries[i].size = ffio_read_varlen(pb);
529  viv->sb_entries[i].flag = avio_r8(pb);
530  }
531 
532  ffio_read_varlen(pb);
533  avio_r8(pb);
534 
535  viv->current_sb_entry = 0;
536 }
537 
539 {
540  VividasDemuxContext *viv = s->priv_data;
541  AVIOContext *pb = s->pb;
542  int64_t header_end;
543  int num_tracks;
544  uint32_t key, k2;
545  uint32_t v;
546  uint8_t keybuffer[187];
547  uint32_t b22_size = 0;
548  uint32_t b22_key = 0;
549  uint8_t *buf = 0;
550  int ret;
551 
552  avio_skip(pb, 9);
553 
554  header_end = avio_tell(pb);
555 
556  header_end += ffio_read_varlen(pb);
557 
558  num_tracks = avio_r8(pb);
559 
560  if (num_tracks != 1) {
561  av_log(s, AV_LOG_ERROR, "number of tracks %d is not 1\n", num_tracks);
562  return AVERROR(EINVAL);
563  }
564 
565  v = avio_r8(pb);
566  avio_seek(pb, v, SEEK_CUR);
567 
568  avio_read(pb, keybuffer, 187);
569  key = decode_key(keybuffer);
570  viv->sb_key = key;
571 
572  avio_rl32(pb);
573 
574  for (;;) {
575  int64_t here = avio_tell(pb);
576  int block_len, block_type;
577 
578  if (here >= header_end)
579  break;
580 
581  block_len = ffio_read_varlen(pb);
582  if (avio_feof(pb) || block_len <= 0)
583  return AVERROR_INVALIDDATA;
584 
585  block_type = avio_r8(pb);
586 
587  if (block_type == 22) {
588  avio_read(pb, keybuffer, 187);
589  b22_key = decode_key(keybuffer);
590  b22_size = avio_rl32(pb);
591  }
592 
593  avio_seek(pb, here + block_len, SEEK_SET);
594  }
595 
596  if (b22_size) {
597  k2 = b22_key;
598  buf = read_vblock(pb, &v, b22_key, &k2, 0);
599  if (!buf)
600  return AVERROR(EIO);
601 
602  av_free(buf);
603  }
604 
605  k2 = key;
606  buf = read_vblock(pb, &v, key, &k2, 0);
607  if (!buf)
608  return AVERROR(EIO);
609  ret = track_header(viv, s, buf, v);
610  av_free(buf);
611  if (ret < 0)
612  return ret;
613 
614  buf = read_vblock(pb, &v, key, &k2, v);
615  if (!buf)
616  return AVERROR(EIO);
617  ret = track_index(viv, s, buf, v);
618  av_free(buf);
619  if (ret < 0)
620  return ret;
621 
622  viv->sb_offset = avio_tell(pb);
623  if (viv->n_sb_blocks > 0) {
624  viv->current_sb = 0;
625  load_sb_block(s, viv, viv->sb_blocks[0].size);
626  } else {
627  viv->current_sb = -1;
628  }
629 
630  return 0;
631 }
632 
634  AVPacket *pkt)
635 {
636  VividasDemuxContext *viv = s->priv_data;
637  AVIOContext *pb;
638  int64_t off;
639  int ret;
640 
641  if (!viv->sb_pb)
642  return AVERROR(EIO);
643  if (avio_feof(viv->sb_pb))
644  return AVERROR_EOF;
645 
647  AVStream *astream;
649 
650  pb = viv->sb_pb;
651  ret = av_get_packet(pb, pkt, size);
652  if (ret < 0)
653  return ret;
654  pkt->pos += viv->sb_offset + viv->sb_blocks[viv->current_sb].byte_offset;
655 
656  pkt->stream_index = 1;
657  astream = s->streams[pkt->stream_index];
658 
659  pkt->pts = av_rescale_q(viv->audio_sample, av_make_q(1, astream->codecpar->sample_rate), astream->time_base);
661  astream->codecpar->ch_layout.nb_channels;
664  return 0;
665  }
666 
667  if (viv->current_sb_entry >= viv->n_sb_entries) {
668  if (viv->current_sb+1 >= viv->n_sb_blocks)
669  return AVERROR(EIO);
670  viv->current_sb++;
671 
672  load_sb_block(s, viv, 0);
673  viv->current_sb_entry = 0;
674  }
675 
676  pb = viv->sb_pb;
677  if (!pb)
678  return AVERROR(EIO);
679  off = avio_tell(pb);
680 
681  if (viv->current_sb_entry >= viv->n_sb_entries)
682  return AVERROR_INVALIDDATA;
683 
684  off += viv->sb_entries[viv->current_sb_entry].size;
685 
686  if (viv->sb_entries[viv->current_sb_entry].flag == 0) {
687  uint64_t v_size = ffio_read_varlen(pb);
688  int last = 0, last_start;
689 
690  if (!viv->num_audio)
691  return AVERROR_INVALIDDATA;
692 
693  ffio_read_varlen(pb);
694  if (v_size > INT_MAX || !v_size)
695  return AVERROR_INVALIDDATA;
696  ret = av_get_packet(pb, pkt, v_size);
697  if (ret < 0)
698  return ret;
699  pkt->pos += viv->sb_offset + viv->sb_blocks[viv->current_sb].byte_offset;
700 
702  pkt->flags |= (pkt->data[0]&0x80)?0:AV_PKT_FLAG_KEY;
703  pkt->stream_index = 0;
704 
705  for (int i = 0; i < MAX_AUDIO_SUBPACKETS - 1; i++) {
706  int start, pcm_bytes;
707  start = ffio_read_varlen(pb);
708  pcm_bytes = ffio_read_varlen(pb);
709 
710  if (i > 0 && start == 0)
711  break;
712  if (start < last)
713  return AVERROR_INVALIDDATA;
714 
715  viv->n_audio_subpackets = i + 1;
716  last =
717  viv->audio_subpackets[i].start = start;
718  viv->audio_subpackets[i].pcm_bytes = pcm_bytes;
719  }
720  last_start =
721  viv->audio_subpackets[viv->n_audio_subpackets].start = (int)(off - avio_tell(pb));
722  if (last_start < last)
723  return AVERROR_INVALIDDATA;
724  viv->current_audio_subpacket = 0;
725 
726  } else {
727  uint64_t v_size = ffio_read_varlen(pb);
728 
729  if (v_size > INT_MAX || !v_size)
730  return AVERROR_INVALIDDATA;
731  ret = av_get_packet(pb, pkt, v_size);
732  if (ret < 0)
733  return ret;
734  pkt->pos += viv->sb_offset + viv->sb_blocks[viv->current_sb].byte_offset;
736  pkt->flags |= (pkt->data[0] & 0x80) ? 0 : AV_PKT_FLAG_KEY;
737  pkt->stream_index = 0;
738  }
739 
740  viv->current_sb_entry++;
741 
742  return 0;
743 }
744 
746 {
747  VividasDemuxContext *viv = s->priv_data;
748 
749  av_freep(&viv->sb_pb);
750  av_freep(&viv->sb_buf);
751  av_freep(&viv->sb_blocks);
752  av_freep(&viv->sb_entries);
753 
754  return 0;
755 }
756 
757 static int viv_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
758 {
759  VividasDemuxContext *viv = s->priv_data;
760  int64_t frame;
761 
762  if (stream_index == 0)
763  frame = timestamp;
764  else
765  frame = av_rescale_q(timestamp, s->streams[0]->time_base, s->streams[stream_index]->time_base);
766 
767  for (int i = 0; i < viv->n_sb_blocks; i++) {
768  if (frame >= viv->sb_blocks[i].packet_offset && frame < viv->sb_blocks[i].packet_offset + viv->sb_blocks[i].n_packets) {
769  viv->current_sb = i;
770  // seek to ith sb block
771  avio_seek(s->pb, viv->sb_offset + viv->sb_blocks[i].byte_offset, SEEK_SET);
772  // load the block
773  load_sb_block(s, viv, 0);
774  if (viv->num_audio) {
775  const AVCodecParameters *par = s->streams[1]->codecpar;
776  // flush audio packet queue
777  viv->current_audio_subpacket = 0;
778  viv->n_audio_subpackets = 0;
779  // most problematic part: guess audio offset
781  av_make_q(par->sample_rate, 1),
782  av_inv_q(s->streams[0]->time_base));
783  // hand-tuned 1.s a/v offset
784  viv->audio_sample += par->sample_rate;
785  }
786  viv->current_sb_entry = 0;
787  return 1;
788  }
789  }
790  return 0;
791 }
792 
794  .name = "vividas",
795  .long_name = NULL_IF_CONFIG_SMALL("Vividas VIV"),
796  .priv_data_size = sizeof(VividasDemuxContext),
797  .flags_internal = FF_FMT_INIT_CLEANUP,
803 };
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
put_v
static void put_v(uint8_t *p, unsigned v)
Definition: vividas.c:102
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:69
FF_FMT_INIT_CLEANUP
#define FF_FMT_INIT_CLEANUP
For an AVInputFormat with this flag set read_close() needs to be called by the caller upon read_heade...
Definition: internal.h:46
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:250
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)
Add a new stream to a media file.
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
VividasDemuxContext::sb_buf
uint8_t * sb_buf
Definition: vividas.c:62
AVPacket::data
uint8_t * data
Definition: packet.h:522
avio_alloc_context
AVIOContext * avio_alloc_context(unsigned char *buffer, int buffer_size, int write_flag, void *opaque, int(*read_packet)(void *opaque, uint8_t *buf, int buf_size), int(*write_packet)(void *opaque, const uint8_t *buf, int buf_size), int64_t(*seek)(void *opaque, int64_t offset, int whence))
Allocate and initialize an AVIOContext for buffered I/O.
Definition: aviobuf.c:144
AV_CODEC_ID_VP6
@ AV_CODEC_ID_VP6
Definition: codec_id.h:143
VividasDemuxContext::current_sb_entry
int current_sb_entry
Definition: vividas.c:61
VIV_SB_block
Definition: vividas.c:39
ffio_init_read_context
void ffio_init_read_context(FFIOContext *s, const uint8_t *buffer, int buffer_size)
Wrap a buffer in an AVIOContext for reading.
Definition: aviobuf.c:134
VividasDemuxContext::audio_sample
int64_t audio_sample
Definition: vividas.c:70
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:323
VIV_SB_block::byte_offset
int64_t byte_offset
Definition: vividas.c:41
VividasDemuxContext::current_audio_subpacket
int current_audio_subpacket
Definition: vividas.c:68
get_v
static uint32_t get_v(uint8_t *p, int len)
Definition: vividas.c:182
track_index
static int track_index(VividasDemuxContext *viv, AVFormatContext *s, const uint8_t *buf, unsigned size)
Definition: vividas.c:436
avio_size
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:370
FFIOContext
Definition: avio_internal.h:28
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:577
VividasDemuxContext::n_sb_blocks
int n_sb_blocks
Definition: vividas.c:54
read_vblock
static uint8_t * read_vblock(AVIOContext *src, uint32_t *size, uint32_t key, uint32_t *k2, int align)
Definition: vividas.c:197
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
recover_key
static unsigned recover_key(unsigned char sample[4], unsigned expected_size)
Definition: vividas.c:114
decode_block
static void decode_block(uint8_t *src, uint8_t *dest, unsigned size, uint32_t key, uint32_t *key_ptr, int align)
Definition: vividas.c:142
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:464
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: avformat.c:830
VIV_AudioSubpacket::start
int start
Definition: vividas.c:50
read_seek
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:151
viv_read_header
static int viv_read_header(AVFormatContext *s)
Definition: vividas.c:538
read_close
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:143
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:513
VividasDemuxContext::num_audio
int num_audio
Definition: vividas.c:56
VividasDemuxContext::current_sb
int current_sb
Definition: vividas.c:61
avio_rl16
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:761
avassert.h
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AVInputFormat
Definition: avformat.h:549
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_read_callback.c:41
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
viv_read_seek
static int viv_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: vividas.c:757
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:554
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:454
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:121
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
VIV_SB_entry
Definition: vividas.c:45
key
const char * key
Definition: hwcontext_opencl.c:174
frame
static AVFrame * frame
Definition: demux_decode.c:54
AVFormatContext
Format I/O context.
Definition: avformat.h:1202
VIV_SB_entry::size
int size
Definition: vividas.c:46
internal.h
VividasDemuxContext::audio_subpackets
VIV_AudioSubpacket audio_subpackets[MAX_AUDIO_SUBPACKETS]
Definition: vividas.c:72
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:864
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:550
AVStream::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avformat.h:880
NULL
#define NULL
Definition: coverity.c:32
VIV_AudioSubpacket
Definition: vividas.c:49
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
read_sb_block
static uint8_t * read_sb_block(AVIOContext *src, unsigned *size, uint32_t *key, unsigned expected_size)
Definition: vividas.c:232
VIV_SB_block::n_packets
int n_packets
Definition: vividas.c:40
xor_block
static void xor_block(void *p1, void *p2, unsigned size, int key, unsigned *key_ptr)
Definition: vividas.c:123
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:452
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:206
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:171
AVStream::nb_frames
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:902
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:73
avio_rl32
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:777
AVIOContext
Bytestream IO Context.
Definition: avio.h:166
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:106
av_bswap32
#define av_bswap32
Definition: bswap.h:28
FFIOContext::pub
AVIOContext pub
Definition: avio_internal.h:29
plaintext
static const uint8_t plaintext[8]
Definition: blowfish.c:112
sample
#define sample
Definition: flacdsp_template.c:44
size
int size
Definition: twinvq_data.h:10344
av_make_q
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
av_xiphlacing
unsigned int av_xiphlacing(unsigned char *s, unsigned int v)
Encode extradata length to a buffer.
Definition: utils.c:838
align
static const uint8_t *BS_FUNC() align(BSCTX *bc)
Skip bits to a byte boundary.
Definition: bitstream_template.h:411
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:650
VIV_SB_entry::flag
int flag
Definition: vividas.c:46
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:528
ffio_read_varlen
uint64_t ffio_read_varlen(AVIOContext *bc)
Definition: aviobuf.c:963
VIV_SB_block::size
int size
Definition: vividas.c:40
MAX_AUDIO_SUBPACKETS
#define MAX_AUDIO_SUBPACKETS
Definition: vividas.c:37
filesize
static int64_t filesize(AVIOContext *pb)
Definition: ffmpeg_mux.c:51
load_sb_block
static void load_sb_block(AVFormatContext *s, VividasDemuxContext *viv, unsigned expected_size)
Definition: vividas.c:494
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:515
VividasDemuxContext::sb_key
uint32_t sb_key
Definition: vividas.c:58
avio_internal.h
AVCodecParameters::height
int height
Definition: codec_par.h:122
decode_key
static uint32_t decode_key(uint8_t *buf)
Definition: vividas.c:90
VividasDemuxContext
Definition: vividas.c:53
VIV_SB_block::packet_offset
int64_t packet_offset
Definition: vividas.c:42
a2
#define a2
Definition: regdef.h:48
delta
float delta
Definition: vorbis_enc_data.h:430
viv_probe
static int viv_probe(const AVProbeData *p)
Definition: vividas.c:75
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
len
int len
Definition: vorbis_enc_data.h:426
ff_vividas_demuxer
const AVInputFormat ff_vividas_demuxer
Definition: vividas.c:793
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:262
av_get_packet
int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
Allocate and read the payload of a packet and initialize its fields with default values.
Definition: utils.c:103
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:853
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:841
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:278
keybits
static const uint8_t keybits[32]
Definition: vividas.c:83
avformat.h
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
viv_read_packet
static int viv_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: vividas.c:633
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:659
VividasDemuxContext::n_audio_subpackets
int n_audio_subpackets
Definition: vividas.c:67
AVPacket::stream_index
int stream_index
Definition: packet.h:524
VividasDemuxContext::n_sb_entries
int n_sb_entries
Definition: vividas.c:64
VividasDemuxContext::sb_pb
AVIOContext * sb_pb
Definition: vividas.c:63
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:365
track_header
static int track_header(VividasDemuxContext *viv, AVFormatContext *s, const uint8_t *buf, int size)
Definition: vividas.c:280
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
read_probe
static int read_probe(const AVProbeData *p)
Definition: cdg.c:29
VividasDemuxContext::sb_offset
int64_t sb_offset
Definition: vividas.c:59
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
VIV_AudioSubpacket::pcm_bytes
int pcm_bytes
Definition: vividas.c:50
VividasDemuxContext::sb_entries
VIV_SB_entry * sb_entries
Definition: vividas.c:65
viv_read_close
static int viv_read_close(AVFormatContext *s)
Definition: vividas.c:745
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
VividasDemuxContext::sb_blocks
VIV_SB_block * sb_blocks
Definition: vividas.c:55
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
AVPacket
This structure stores compressed data.
Definition: packet.h:499
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:542
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
AV_CODEC_ID_VORBIS
@ AV_CODEC_ID_VORBIS
Definition: codec_id.h:448
int
int
Definition: ffmpeg_filter.c:424
ff_alloc_extradata
int ff_alloc_extradata(AVCodecParameters *par, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0.
Definition: utils.c:239
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:393