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/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 {
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;
51 
52 typedef struct VividasDemuxContext {
55  int num_audio;
56 
57  uint32_t sb_key;
58  int64_t sb_offset;
59 
60  int current_sb, current_sb_entry;
65 
68 
69  int64_t audio_sample;
70 
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");
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 
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 
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  if (avio_feof(pb))
297  return AVERROR_EOF;
298  for (j=0;j<c;j++) {
299  if (avio_feof(pb))
300  return AVERROR_EOF;
301  avio_r8(pb); // val_3
302  avio_r8(pb); // val_4
303  }
304  }
305 
306  avio_r8(pb); // num_streams
307 
308  off = avio_tell(pb);
309  off += ffio_read_varlen(pb); // val_5
310 
311  avio_r8(pb); // '2'
312  num_video = avio_r8(pb);
313 
314  avio_seek(pb, off, SEEK_SET);
315  if (num_video != 1) {
316  av_log(s, AV_LOG_ERROR, "number of video tracks %d is not 1\n", num_video);
317  return AVERROR_PATCHWELCOME;
318  }
319 
320  for (i = 0; i < num_video; i++) {
322  if (!st)
323  return AVERROR(ENOMEM);
324 
325  st->id = i;
326 
329 
330  off = avio_tell(pb);
331  off += ffio_read_varlen(pb);
332  avio_r8(pb); // '3'
333  avio_r8(pb); // val_7
334  st->time_base.num = avio_rl32(pb); // frame_time
335  st->time_base.den = avio_rl32(pb); // time_base
336  st->nb_frames = avio_rl32(pb); // n frames
337  st->codecpar->width = avio_rl16(pb); // width
338  st->codecpar->height = avio_rl16(pb); // height
339  avio_r8(pb); // val_8
340  avio_rl32(pb); // val_9
341 
342  avio_seek(pb, off, SEEK_SET);
343  }
344 
345  off = avio_tell(pb);
346  off += ffio_read_varlen(pb); // val_10
347  avio_r8(pb); // '4'
348  viv->num_audio = avio_r8(pb);
349  avio_seek(pb, off, SEEK_SET);
350 
351  if (viv->num_audio != 1)
352  av_log(s, AV_LOG_WARNING, "number of audio tracks %d is not 1\n", viv->num_audio);
353 
354  for(i=0;i<viv->num_audio;i++) {
355  int q;
357  if (!st)
358  return AVERROR(ENOMEM);
359 
360  st->id = num_video + i;
361 
364 
365  off = avio_tell(pb);
366  off += ffio_read_varlen(pb); // length
367  avio_r8(pb); // '5'
368  avio_r8(pb); //codec_id
369  avio_rl16(pb); //codec_subid
370  st->codecpar->channels = avio_rl16(pb); // channels
371  st->codecpar->sample_rate = avio_rl32(pb); // sample_rate
372  avio_seek(pb, 10, SEEK_CUR); // data_1
373  q = avio_r8(pb);
374  avio_seek(pb, q, SEEK_CUR); // data_2
375  avio_r8(pb); // zeropad
376 
377  if (avio_tell(pb) < off) {
378  int num_data;
379  int xd_size = 0;
380  int data_len[256];
381  int offset = 1;
382  uint8_t *p;
383  ffio_read_varlen(pb); // val_13
384  avio_r8(pb); // '19'
385  ffio_read_varlen(pb); // len_3
386  num_data = avio_r8(pb);
387  for (j = 0; j < num_data; j++) {
388  uint64_t len = ffio_read_varlen(pb);
389  if (len > INT_MAX/2 - xd_size) {
390  return AVERROR_INVALIDDATA;
391  }
392  data_len[j] = len;
393  xd_size += len;
394  }
395 
396  ret = ff_alloc_extradata(st->codecpar, 64 + xd_size + xd_size / 255);
397  if (ret < 0)
398  return ret;
399 
400  p = st->codecpar->extradata;
401  p[0] = 2;
402 
403  for (j = 0; j < num_data - 1; j++) {
404  unsigned delta = av_xiphlacing(&p[offset], data_len[j]);
405  if (delta > data_len[j]) {
406  return AVERROR_INVALIDDATA;
407  }
408  offset += delta;
409  }
410 
411  for (j = 0; j < num_data; j++) {
412  int ret = avio_read(pb, &p[offset], data_len[j]);
413  if (ret < data_len[j]) {
414  st->codecpar->extradata_size = 0;
415  av_freep(&st->codecpar->extradata);
416  break;
417  }
418  offset += data_len[j];
419  }
420 
421  if (offset < st->codecpar->extradata_size)
423  }
424  }
425 
426  return 0;
427 }
428 
429 static int track_index(VividasDemuxContext *viv, AVFormatContext *s, uint8_t *buf, unsigned size)
430 {
431  int64_t off;
432  int64_t poff;
433  int maxnp=0;
434  AVIOContext pb0, *pb = &pb0;
435  int i;
436  int64_t filesize = avio_size(s->pb);
437  uint64_t n_sb_blocks_tmp;
438 
439  ffio_init_context(pb, buf, size, 0, NULL, NULL, NULL, NULL);
440 
441  ffio_read_varlen(pb); // track_index_len
442  avio_r8(pb); // 'c'
443  n_sb_blocks_tmp = ffio_read_varlen(pb);
444  if (n_sb_blocks_tmp > size / 2)
445  return AVERROR_INVALIDDATA;
446  viv->sb_blocks = av_calloc(n_sb_blocks_tmp, sizeof(*viv->sb_blocks));
447  if (!viv->sb_blocks) {
448  return AVERROR(ENOMEM);
449  }
450  viv->n_sb_blocks = n_sb_blocks_tmp;
451 
452  off = 0;
453  poff = 0;
454 
455  for (i = 0; i < viv->n_sb_blocks; i++) {
456  uint64_t size_tmp = ffio_read_varlen(pb);
457  uint64_t n_packets_tmp = ffio_read_varlen(pb);
458 
459  if (size_tmp > INT_MAX || n_packets_tmp > INT_MAX)
460  return AVERROR_INVALIDDATA;
461 
462  viv->sb_blocks[i].byte_offset = off;
463  viv->sb_blocks[i].packet_offset = poff;
464 
465  viv->sb_blocks[i].size = size_tmp;
466  viv->sb_blocks[i].n_packets = n_packets_tmp;
467 
468  off += viv->sb_blocks[i].size;
469  poff += viv->sb_blocks[i].n_packets;
470 
471  if (maxnp < viv->sb_blocks[i].n_packets)
472  maxnp = viv->sb_blocks[i].n_packets;
473  }
474 
475  if (filesize > 0 && poff > filesize)
476  return AVERROR_INVALIDDATA;
477 
478  viv->sb_entries = av_calloc(maxnp, sizeof(VIV_SB_entry));
479  if (!viv->sb_entries)
480  return AVERROR(ENOMEM);
481 
482  return 0;
483 }
484 
485 static void load_sb_block(AVFormatContext *s, VividasDemuxContext *viv, unsigned expected_size)
486 {
487  uint32_t size = 0;
488  int i;
489  AVIOContext *pb = 0;
490 
491  if (viv->sb_pb) {
492  av_free(viv->sb_pb);
493  viv->sb_pb = NULL;
494  }
495 
496  if (viv->sb_buf)
497  av_free(viv->sb_buf);
498 
499  viv->sb_buf = read_sb_block(s->pb, &size, &viv->sb_key, expected_size);
500  if (!viv->sb_buf) {
501  return;
502  }
503 
504  pb = avio_alloc_context(viv->sb_buf, size, 0, NULL, NULL, NULL, NULL);
505  if (!pb)
506  return;
507 
508  viv->sb_pb = pb;
509 
510  avio_r8(pb); // 'S'
511  avio_r8(pb); // 'B'
512  ffio_read_varlen(pb); // size
513  avio_r8(pb); // junk
514  ffio_read_varlen(pb); // first packet
515 
516  viv->n_sb_entries = viv->sb_blocks[viv->current_sb].n_packets;
517 
518  for (i = 0; i < viv->n_sb_entries; i++) {
519  viv->sb_entries[i].size = ffio_read_varlen(pb);
520  viv->sb_entries[i].flag = avio_r8(pb);
521  }
522 
523  ffio_read_varlen(pb);
524  avio_r8(pb);
525 
526  viv->current_sb_entry = 0;
527 }
528 
530 {
531  VividasDemuxContext *viv = s->priv_data;
532  AVIOContext *pb = s->pb;
533  int64_t header_end;
534  int num_tracks;
535  uint32_t key, k2;
536  uint32_t v;
537  uint8_t keybuffer[187];
538  uint32_t b22_size = 0;
539  uint32_t b22_key = 0;
540  uint8_t *buf = 0;
541  int ret;
542 
543  avio_skip(pb, 9);
544 
545  header_end = avio_tell(pb);
546 
547  header_end += ffio_read_varlen(pb);
548 
549  num_tracks = avio_r8(pb);
550 
551  if (num_tracks != 1) {
552  av_log(s, AV_LOG_ERROR, "number of tracks %d is not 1\n", num_tracks);
553  return AVERROR(EINVAL);
554  }
555 
556  v = avio_r8(pb);
557  avio_seek(pb, v, SEEK_CUR);
558 
559  avio_read(pb, keybuffer, 187);
560  key = decode_key(keybuffer);
561  viv->sb_key = key;
562 
563  avio_rl32(pb);
564 
565  for (;;) {
566  int64_t here = avio_tell(pb);
567  int block_len, block_type;
568 
569  if (here >= header_end)
570  break;
571 
572  block_len = ffio_read_varlen(pb);
573  if (avio_feof(pb) || block_len <= 0)
574  return AVERROR_INVALIDDATA;
575 
576  block_type = avio_r8(pb);
577 
578  if (block_type == 22) {
579  avio_read(pb, keybuffer, 187);
580  b22_key = decode_key(keybuffer);
581  b22_size = avio_rl32(pb);
582  }
583 
584  avio_seek(pb, here + block_len, SEEK_SET);
585  }
586 
587  if (b22_size) {
588  k2 = b22_key;
589  buf = read_vblock(pb, &v, b22_key, &k2, 0);
590  if (!buf)
591  return AVERROR(EIO);
592 
593  av_free(buf);
594  }
595 
596  k2 = key;
597  buf = read_vblock(pb, &v, key, &k2, 0);
598  if (!buf)
599  return AVERROR(EIO);
600  ret = track_header(viv, s, buf, v);
601  av_free(buf);
602  if (ret < 0)
603  return ret;
604 
605  buf = read_vblock(pb, &v, key, &k2, v);
606  if (!buf)
607  return AVERROR(EIO);
608  ret = track_index(viv, s, buf, v);
609  av_free(buf);
610  if (ret < 0)
611  goto fail;
612 
613  viv->sb_offset = avio_tell(pb);
614  if (viv->n_sb_blocks > 0) {
615  viv->current_sb = 0;
616  load_sb_block(s, viv, viv->sb_blocks[0].size);
617  } else {
618  viv->current_sb = -1;
619  }
620 
621  return 0;
622 fail:
623  av_freep(&viv->sb_blocks);
624  return ret;
625 }
626 
628  AVPacket *pkt)
629 {
630  VividasDemuxContext *viv = s->priv_data;
631  AVIOContext *pb;
632  int64_t off;
633  int ret;
634 
635  if (!viv->sb_pb)
636  return AVERROR(EIO);
637  if (avio_feof(viv->sb_pb))
638  return AVERROR_EOF;
639 
641  AVStream *astream;
643 
644  pb = viv->sb_pb;
645  ret = av_get_packet(pb, pkt, size);
646  if (ret < 0)
647  return ret;
648  pkt->pos += viv->sb_offset + viv->sb_blocks[viv->current_sb].byte_offset;
649 
650  pkt->stream_index = 1;
651  astream = s->streams[pkt->stream_index];
652 
653  pkt->pts = av_rescale_q(viv->audio_sample, av_make_q(1, astream->codecpar->sample_rate), astream->time_base);
655  pkt->flags |= AV_PKT_FLAG_KEY;
657  return 0;
658  }
659 
660  if (viv->current_sb_entry >= viv->n_sb_entries) {
661  if (viv->current_sb+1 >= viv->n_sb_blocks)
662  return AVERROR(EIO);
663  viv->current_sb++;
664 
665  load_sb_block(s, viv, 0);
666  viv->current_sb_entry = 0;
667  }
668 
669  pb = viv->sb_pb;
670  if (!pb)
671  return AVERROR(EIO);
672  off = avio_tell(pb);
673  off += viv->sb_entries[viv->current_sb_entry].size;
674 
675  if (viv->sb_entries[viv->current_sb_entry].flag == 0) {
676  uint64_t v_size = ffio_read_varlen(pb);
677 
678  if (!viv->num_audio)
679  return AVERROR_INVALIDDATA;
680 
681  ffio_read_varlen(pb);
682  if (v_size > INT_MAX)
683  return AVERROR_INVALIDDATA;
684  ret = av_get_packet(pb, pkt, v_size);
685  if (ret < 0)
686  return ret;
687  pkt->pos += viv->sb_offset + viv->sb_blocks[viv->current_sb].byte_offset;
688 
689  pkt->pts = viv->sb_blocks[viv->current_sb].packet_offset + viv->current_sb_entry;
690  pkt->flags |= (pkt->data[0]&0x80)?0:AV_PKT_FLAG_KEY;
691  pkt->stream_index = 0;
692 
693  for (int i = 0; i < MAX_AUDIO_SUBPACKETS - 1; i++) {
694  int start, pcm_bytes;
695  start = ffio_read_varlen(pb);
696  pcm_bytes = ffio_read_varlen(pb);
697 
698  if (i > 0 && start == 0)
699  break;
700 
701  viv->n_audio_subpackets = i + 1;
702  viv->audio_subpackets[i].start = start;
703  viv->audio_subpackets[i].pcm_bytes = pcm_bytes;
704  }
705  viv->audio_subpackets[viv->n_audio_subpackets].start = (int)(off - avio_tell(pb));
706  viv->current_audio_subpacket = 0;
707 
708  } else {
709  uint64_t v_size = ffio_read_varlen(pb);
710 
711  if (v_size > INT_MAX)
712  return AVERROR_INVALIDDATA;
713  ret = av_get_packet(pb, pkt, v_size);
714  if (ret < 0)
715  return ret;
716  pkt->pos += viv->sb_offset + viv->sb_blocks[viv->current_sb].byte_offset;
717  pkt->pts = viv->sb_blocks[viv->current_sb].packet_offset + viv->current_sb_entry;
718  pkt->flags |= (pkt->data[0] & 0x80) ? 0 : AV_PKT_FLAG_KEY;
719  pkt->stream_index = 0;
720  }
721 
722  viv->current_sb_entry++;
723 
724  return 0;
725 }
726 
728 {
729  VividasDemuxContext *viv = s->priv_data;
730 
731  av_freep(&viv->sb_pb);
732  av_freep(&viv->sb_buf);
733  av_freep(&viv->sb_blocks);
734  av_freep(&viv->sb_entries);
735 
736  return 0;
737 }
738 
739 static int viv_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
740 {
741  VividasDemuxContext *viv = s->priv_data;
742  int64_t frame;
743 
744  if (stream_index == 0)
745  frame = timestamp;
746  else
747  frame = av_rescale_q(timestamp, s->streams[0]->time_base, s->streams[stream_index]->time_base);
748 
749  for (int i = 0; i < viv->n_sb_blocks; i++) {
750  if (frame >= viv->sb_blocks[i].packet_offset && frame < viv->sb_blocks[i].packet_offset + viv->sb_blocks[i].n_packets) {
751  // flush audio packet queue
752  viv->current_audio_subpacket = 0;
753  viv->n_audio_subpackets = 0;
754  viv->current_sb = i;
755  // seek to ith sb block
756  avio_seek(s->pb, viv->sb_offset + viv->sb_blocks[i].byte_offset, SEEK_SET);
757  // load the block
758  load_sb_block(s, viv, 0);
759  // most problematic part: guess audio offset
761  // hand-tuned 1.s a/v offset
762  viv->audio_sample += s->streams[1]->codecpar->sample_rate;
763  viv->current_sb_entry = 0;
764  return 1;
765  }
766  }
767  return 0;
768 }
769 
771  .name = "vividas",
772  .long_name = NULL_IF_CONFIG_SMALL("Vividas VIV"),
773  .priv_data_size = sizeof(VividasDemuxContext),
779 };
#define NULL
Definition: coverity.c:32
uint64_t ffio_read_varlen(AVIOContext *bc)
Definition: aviobuf.c:912
static uint8_t * read_vblock(AVIOContext *src, uint32_t *size, uint32_t key, uint32_t *k2, int align)
Definition: vividas.c:196
Bytestream IO Context.
Definition: avio.h:161
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:346
static uint32_t get_v(uint8_t *p, int len)
Definition: vividas.c:181
static void decode_block(uint8_t *src, uint8_t *dest, unsigned size, uint32_t key, uint32_t *key_ptr, int align)
Definition: vividas.c:141
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:383
int64_t packet_offset
Definition: vividas.c:41
#define avpriv_request_sample(...)
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:153
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
int num
Numerator.
Definition: rational.h:59
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:253
int n_audio_subpackets
Definition: vividas.c:66
static unsigned recover_key(unsigned char sample[4], unsigned expected_size)
Definition: vividas.c:113
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:341
int size
Definition: vividas.c:45
const char * key
static AVPacket pkt
#define sample
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:245
Format I/O context.
Definition: avformat.h:1355
Definition: vividas.c:44
uint8_t
#define av_malloc(s)
int width
Video only.
Definition: codec_par.h:126
float delta
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
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:92
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
int id
Format-specific stream ID.
Definition: avformat.h:887
VIV_SB_block * sb_blocks
Definition: vividas.c:54
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4450
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:262
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1423
int flag
Definition: vividas.c:45
uint8_t * data
Definition: packet.h:363
#define AVERROR_EOF
End of file.
Definition: error.h:55
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:145
uint32_t sb_key
Definition: vividas.c:57
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:305
ptrdiff_t size
Definition: opengl_enc.c:100
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
#define av_log(a,...)
AVIOContext * sb_pb
Definition: vividas.c:62
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:637
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:401
static const uint8_t plaintext[8]
Definition: blowfish.c:112
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
#define src
Definition: vp8dsp.c:254
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, 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:138
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
static uint8_t * read_sb_block(AVIOContext *src, unsigned *size, uint32_t *key, unsigned expected_size)
Definition: vividas.c:231
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:752
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
static int viv_read_header(AVFormatContext *s)
Definition: vividas.c:529
#define fail()
Definition: checkasm.h:123
int64_t sb_offset
Definition: vividas.c:58
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:369
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:78
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:628
VIV_SB_entry * sb_entries
Definition: vividas.c:64
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:443
static int viv_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: vividas.c:739
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:3259
AVInputFormat ff_vividas_demuxer
Definition: vividas.c:770
static void xor_block(void *p1, void *p2, unsigned size, int key, unsigned *key_ptr)
Definition: vividas.c:122
#define a2
Definition: regdef.h:48
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
#define s(width, name)
Definition: cbs_vp9.c:257
#define MAX_AUDIO_SUBPACKETS
Definition: vividas.c:36
int current_audio_subpacket
Definition: vividas.c:67
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:527
Stream structure.
Definition: avformat.h:880
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
#define av_bswap32
Definition: bswap.h:33
AVIOContext * pb
I/O context.
Definition: avformat.h:1397
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
static uint32_t decode_key(uint8_t *buf)
Definition: vividas.c:89
int64_t audio_sample
Definition: vividas.c:69
unsigned int av_xiphlacing(unsigned char *s, unsigned int v)
Encode extradata length to a buffer.
Definition: utils.c:1809
int n_packets
Definition: vividas.c:39
static int viv_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: vividas.c:627
This structure contains the data a format has to probe a file.
Definition: avformat.h:441
#define flags(name, subs,...)
Definition: cbs_av1.c:560
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
int sample_rate
Audio only.
Definition: codec_par.h:170
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:453
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:736
Main libavformat public API header.
int
static void load_sb_block(AVFormatContext *s, VividasDemuxContext *viv, unsigned expected_size)
Definition: vividas.c:485
int ffio_init_context(AVIOContext *s, 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, uint8_t *buf, int buf_size), int64_t(*seek)(void *opaque, int64_t offset, int whence))
Definition: aviobuf.c:88
#define flag(name)
Definition: cbs_av1.c:552
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:931
uint8_t * sb_buf
Definition: vividas.c:61
int den
Denominator.
Definition: rational.h:60
static int viv_read_close(AVFormatContext *s)
Definition: vividas.c:727
static int viv_probe(const AVProbeData *p)
Definition: vividas.c:74
#define av_free(p)
int len
void * priv_data
Format private data.
Definition: avformat.h:1383
static int track_header(VividasDemuxContext *viv, AVFormatContext *s, uint8_t *buf, int size)
Definition: vividas.c:279
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
int channels
Audio only.
Definition: codec_par.h:166
static const uint8_t keybits[32]
Definition: vividas.c:82
#define av_freep(p)
VIV_AudioSubpacket audio_subpackets[MAX_AUDIO_SUBPACKETS]
Definition: vividas.c:71
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:652
static int track_index(VividasDemuxContext *viv, AVFormatContext *s, uint8_t *buf, unsigned size)
Definition: vividas.c:429
int size
Definition: vividas.c:39
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1027
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:368
int stream_index
Definition: packet.h:365
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:909
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
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:91
This structure stores compressed data.
Definition: packet.h:340
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:356
int i
Definition: input.c:407
static void put_v(uint8_t *p, unsigned v)
Definition: vividas.c:101
int64_t byte_offset
Definition: vividas.c:40
static uint8_t tmp[11]
Definition: aes_ctr.c:26