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\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 
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;
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++) {
320  if (!st)
321  return AVERROR(ENOMEM);
322 
323  st->id = i;
324 
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;
355  if (!st)
356  return AVERROR(ENOMEM);
357 
358  st->id = num_video + i;
359 
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  st->codecpar->extradata_size = 64 + xd_size + xd_size / 255;
396  return AVERROR(ENOMEM);
397  }
398 
399  p = st->codecpar->extradata;
400  p[0] = 2;
401 
402  for (j = 0; j < num_data - 1; j++) {
403  unsigned delta = av_xiphlacing(&p[offset], data_len[j]);
404  if (delta > data_len[j]) {
405  return AVERROR_INVALIDDATA;
406  }
407  offset += delta;
408  }
409 
410  for (j = 0; j < num_data; j++) {
411  int ret = avio_read(pb, &p[offset], data_len[j]);
412  if (ret < data_len[j]) {
413  st->codecpar->extradata_size = 0;
414  av_freep(&st->codecpar->extradata);
415  break;
416  }
417  offset += data_len[j];
418  }
419 
420  if (offset < st->codecpar->extradata_size)
422  }
423  }
424 
425  return 0;
426 }
427 
429 {
430  int64_t off;
431  int64_t poff;
432  int maxnp=0;
433  AVIOContext pb0, *pb = &pb0;
434  int i;
435  int64_t filesize = avio_size(s->pb);
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  viv->n_sb_blocks = ffio_read_varlen(pb);
442  if (viv->n_sb_blocks < 0 || viv->n_sb_blocks > size / 2)
443  goto error;
444  viv->sb_blocks = av_calloc(viv->n_sb_blocks, sizeof(VIV_SB_block));
445  if (!viv->sb_blocks) {
446  viv->n_sb_blocks = 0;
447  return AVERROR(ENOMEM);
448  }
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  goto error;
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  goto error;
475 
476  viv->sb_entries = av_calloc(maxnp, sizeof(VIV_SB_entry));
477 
478  return 0;
479 error:
480  viv->n_sb_blocks = 0;
481  av_freep(&viv->sb_blocks);
482  return AVERROR_INVALIDDATA;
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  return ret;
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 }
623 
625  AVPacket *pkt)
626 {
627  VividasDemuxContext *viv = s->priv_data;
628  AVIOContext *pb;
629  int64_t off;
630  int ret;
631 
632  if (!viv->sb_pb)
633  return AVERROR(EIO);
634  if (avio_feof(viv->sb_pb))
635  return AVERROR_EOF;
636 
638  AVStream *astream;
640 
641  pb = viv->sb_pb;
642  ret = av_get_packet(pb, pkt, size);
643  if (ret < 0)
644  return ret;
645  pkt->pos += viv->sb_offset + viv->sb_blocks[viv->current_sb].byte_offset;
646 
647  pkt->stream_index = 1;
648  astream = s->streams[pkt->stream_index];
649 
650  pkt->pts = av_rescale(viv->audio_sample, astream->time_base.den, astream->time_base.num) / astream->codecpar->sample_rate;
652  pkt->flags |= AV_PKT_FLAG_KEY;
654  return 0;
655  }
656 
657  if (viv->current_sb_entry >= viv->n_sb_entries) {
658  if (viv->current_sb+1 >= viv->n_sb_blocks)
659  return AVERROR(EIO);
660  viv->current_sb++;
661 
662  load_sb_block(s, viv, 0);
663  viv->current_sb_entry = 0;
664  }
665 
666  pb = viv->sb_pb;
667  if (!pb)
668  return AVERROR(EIO);
669  off = avio_tell(pb);
670  off += viv->sb_entries[viv->current_sb_entry].size;
671 
672  if (viv->sb_entries[viv->current_sb_entry].flag == 0) {
673  uint64_t v_size = ffio_read_varlen(pb);
674 
675  if (!viv->num_audio)
676  return AVERROR_INVALIDDATA;
677 
678  ffio_read_varlen(pb);
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 
686  pkt->pts = viv->sb_blocks[viv->current_sb].packet_offset + viv->current_sb_entry;
687  pkt->flags |= (pkt->data[0]&0x80)?0:AV_PKT_FLAG_KEY;
688  pkt->stream_index = 0;
689 
690  for (int i = 0; i < MAX_AUDIO_SUBPACKETS - 1; i++) {
691  int start, pcm_bytes;
692  start = ffio_read_varlen(pb);
693  pcm_bytes = ffio_read_varlen(pb);
694 
695  if (i > 0 && start == 0)
696  break;
697 
698  viv->n_audio_subpackets = i + 1;
699  viv->audio_subpackets[i].start = start;
700  viv->audio_subpackets[i].pcm_bytes = pcm_bytes;
701  }
702  viv->audio_subpackets[viv->n_audio_subpackets].start = (int)(off - avio_tell(pb));
703  viv->current_audio_subpacket = 0;
704 
705  } else {
706  uint64_t v_size = ffio_read_varlen(pb);
707 
708  if (v_size > INT_MAX)
709  return AVERROR_INVALIDDATA;
710  ret = av_get_packet(pb, pkt, v_size);
711  if (ret < 0)
712  return ret;
713  pkt->pos += viv->sb_offset + viv->sb_blocks[viv->current_sb].byte_offset;
714  pkt->pts = viv->sb_blocks[viv->current_sb].packet_offset + viv->current_sb_entry;
715  pkt->flags |= (pkt->data[0] & 0x80) ? 0 : AV_PKT_FLAG_KEY;
716  pkt->stream_index = 0;
717  }
718 
719  viv->current_sb_entry++;
720 
721  return 0;
722 }
723 
725 {
726  VividasDemuxContext *viv = s->priv_data;
727 
728  av_freep(&viv->sb_pb);
729  av_freep(&viv->sb_buf);
730  av_freep(&viv->sb_blocks);
731  av_freep(&viv->sb_entries);
732 
733  return 0;
734 }
735 
736 static int viv_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
737 {
738  VividasDemuxContext *viv = s->priv_data;
739  int64_t frame;
740 
741  if (stream_index == 0)
742  frame = timestamp;
743  else
744  frame = av_rescale_q(timestamp, s->streams[0]->time_base, s->streams[stream_index]->time_base);
745 
746  for (int i = 0; i < viv->n_sb_blocks; i++) {
747  if (frame >= viv->sb_blocks[i].packet_offset && frame < viv->sb_blocks[i].packet_offset + viv->sb_blocks[i].n_packets) {
748  // flush audio packet queue
749  viv->current_audio_subpacket = 0;
750  viv->n_audio_subpackets = 0;
751  viv->current_sb = i;
752  // seek to ith sb block
753  avio_seek(s->pb, viv->sb_offset + viv->sb_blocks[i].byte_offset, SEEK_SET);
754  // load the block
755  load_sb_block(s, viv, 0);
756  // most problematic part: guess audio offset
758  // hand-tuned 1.s a/v offset
759  viv->audio_sample += s->streams[1]->codecpar->sample_rate;
760  viv->current_sb_entry = 0;
761  return 1;
762  }
763  }
764  return 0;
765 }
766 
768  .name = "vividas",
769  .long_name = NULL_IF_CONFIG_SMALL("Vividas VIV"),
770  .priv_data_size = sizeof(VividasDemuxContext),
776 };
#define NULL
Definition: coverity.c:32
uint64_t ffio_read_varlen(AVIOContext *bc)
Definition: aviobuf.c:932
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:339
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:182
int64_t pos
byte position in stream, -1 if unknown
Definition: avcodec.h:1502
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: avcodec.h:3970
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:246
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:334
int size
Definition: vividas.c:45
const char * key
static AVPacket pkt
static void error(const char *err)
#define src
Definition: vp8dsp.c:254
#define sample
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
Definition: mem.c:244
Format I/O context.
Definition: avformat.h:1358
Definition: vividas.c:44
uint8_t
#define av_malloc(s)
int width
Video only.
Definition: avcodec.h:4036
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:90
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:888
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:4502
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:252
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1426
int flag
Definition: vividas.c:45
uint8_t * data
Definition: avcodec.h:1482
#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:310
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:650
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1514
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
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:131
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
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:772
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3966
static int viv_read_header(AVFormatContext *s)
Definition: vividas.c:529
int64_t sb_offset
Definition: vividas.c:58
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1488
int extradata_size
Size of the extradata content in bytes.
Definition: avcodec.h:3988
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:641
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:448
static int viv_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: vividas.c:736
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:3321
AVInputFormat ff_vividas_demuxer
Definition: vividas.c:767
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
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
int n
Definition: avisynth_c.h:760
#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:530
Stream structure.
Definition: avformat.h:881
#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
const AVS_VideoInfo int align
Definition: avisynth_c.h:887
#define av_bswap32
Definition: bswap.h:33
AVIOContext * pb
I/O context.
Definition: avformat.h:1400
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
void * buf
Definition: avisynth_c.h:766
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:1763
int n_packets
Definition: vividas.c:39
static int viv_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: vividas.c:624
This structure contains the data a format has to probe a file.
Definition: avformat.h:446
#define flags(name, subs,...)
Definition: cbs_av1.c:561
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: avcodec.h:4080
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:458
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:756
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:81
#define flag(name)
Definition: cbs_av1.c:553
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:932
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:724
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:1386
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: avcodec.h:3984
int channels
Audio only.
Definition: avcodec.h:4076
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
void INT64 start
Definition: avisynth_c.h:766
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:654
static int track_index(VividasDemuxContext *viv, AVFormatContext *s, uint8_t *buf, unsigned size)
Definition: vividas.c:428
int size
Definition: vividas.c:39
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1028
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:361
int stream_index
Definition: avcodec.h:1484
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:910
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:87
This structure stores compressed data.
Definition: avcodec.h:1459
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1475
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