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, ret;
282  int64_t off;
283  int val_1;
284  int num_video;
285  AVIOContext pb0, *pb = &pb0;
286 
287  ffio_init_context(pb, buf, size, 0, NULL, NULL, NULL, NULL);
288 
289  ffio_read_varlen(pb); // track_header_len
290  avio_r8(pb); // '1'
291 
292  val_1 = ffio_read_varlen(pb);
293 
294  for (i=0;i<val_1;i++) {
295  int c = avio_r8(pb);
296  for (j=0;j<c;j++) {
297  if (avio_feof(pb))
298  return AVERROR_EOF;
299  avio_r8(pb); // val_3
300  avio_r8(pb); // val_4
301  }
302  }
303 
304  avio_r8(pb); // num_streams
305 
306  off = avio_tell(pb);
307  off += ffio_read_varlen(pb); // val_5
308 
309  avio_r8(pb); // '2'
310  num_video = avio_r8(pb);
311 
312  avio_seek(pb, off, SEEK_SET);
313  if (num_video != 1) {
314  av_log(s, AV_LOG_ERROR, "number of video tracks %d is not 1\n", num_video);
315  return AVERROR_PATCHWELCOME;
316  }
317 
318  for (i = 0; i < num_video; i++) {
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  ret = ff_alloc_extradata(st->codecpar, 64 + xd_size + xd_size / 255);
395  if (ret < 0)
396  return ret;
397 
398  p = st->codecpar->extradata;
399  p[0] = 2;
400 
401  for (j = 0; j < num_data - 1; j++) {
402  unsigned delta = av_xiphlacing(&p[offset], data_len[j]);
403  if (delta > data_len[j]) {
404  return AVERROR_INVALIDDATA;
405  }
406  offset += delta;
407  }
408 
409  for (j = 0; j < num_data; j++) {
410  int ret = avio_read(pb, &p[offset], data_len[j]);
411  if (ret < data_len[j]) {
412  st->codecpar->extradata_size = 0;
413  av_freep(&st->codecpar->extradata);
414  break;
415  }
416  offset += data_len[j];
417  }
418 
419  if (offset < st->codecpar->extradata_size)
421  }
422  }
423 
424  return 0;
425 }
426 
427 static int track_index(VividasDemuxContext *viv, AVFormatContext *s, uint8_t *buf, unsigned size)
428 {
429  int64_t off;
430  int64_t poff;
431  int maxnp=0;
432  AVIOContext pb0, *pb = &pb0;
433  int i;
434  int64_t filesize = avio_size(s->pb);
435  uint64_t n_sb_blocks_tmp;
436 
437  ffio_init_context(pb, buf, size, 0, NULL, NULL, NULL, NULL);
438 
439  ffio_read_varlen(pb); // track_index_len
440  avio_r8(pb); // 'c'
441  n_sb_blocks_tmp = ffio_read_varlen(pb);
442  if (n_sb_blocks_tmp > size / 2)
443  return AVERROR_INVALIDDATA;
444  viv->sb_blocks = av_calloc(n_sb_blocks_tmp, sizeof(*viv->sb_blocks));
445  if (!viv->sb_blocks) {
446  return AVERROR(ENOMEM);
447  }
448  viv->n_sb_blocks = n_sb_blocks_tmp;
449 
450  off = 0;
451  poff = 0;
452 
453  for (i = 0; i < viv->n_sb_blocks; i++) {
454  uint64_t size_tmp = ffio_read_varlen(pb);
455  uint64_t n_packets_tmp = ffio_read_varlen(pb);
456 
457  if (size_tmp > INT_MAX || n_packets_tmp > INT_MAX)
458  return AVERROR_INVALIDDATA;
459 
460  viv->sb_blocks[i].byte_offset = off;
461  viv->sb_blocks[i].packet_offset = poff;
462 
463  viv->sb_blocks[i].size = size_tmp;
464  viv->sb_blocks[i].n_packets = n_packets_tmp;
465 
466  off += viv->sb_blocks[i].size;
467  poff += viv->sb_blocks[i].n_packets;
468 
469  if (maxnp < viv->sb_blocks[i].n_packets)
470  maxnp = viv->sb_blocks[i].n_packets;
471  }
472 
473  if (filesize > 0 && poff > filesize)
474  return AVERROR_INVALIDDATA;
475 
476  viv->sb_entries = av_calloc(maxnp, sizeof(VIV_SB_entry));
477  if (!viv->sb_entries)
478  return AVERROR(ENOMEM);
479 
480  return 0;
481 }
482 
483 static void load_sb_block(AVFormatContext *s, VividasDemuxContext *viv, unsigned expected_size)
484 {
485  uint32_t size = 0;
486  int i;
487  AVIOContext *pb = 0;
488 
489  if (viv->sb_pb) {
490  av_free(viv->sb_pb);
491  viv->sb_pb = NULL;
492  }
493 
494  if (viv->sb_buf)
495  av_free(viv->sb_buf);
496 
497  viv->sb_buf = read_sb_block(s->pb, &size, &viv->sb_key, expected_size);
498  if (!viv->sb_buf) {
499  return;
500  }
501 
502  pb = avio_alloc_context(viv->sb_buf, size, 0, NULL, NULL, NULL, NULL);
503  if (!pb)
504  return;
505 
506  viv->sb_pb = pb;
507 
508  avio_r8(pb); // 'S'
509  avio_r8(pb); // 'B'
510  ffio_read_varlen(pb); // size
511  avio_r8(pb); // junk
512  ffio_read_varlen(pb); // first packet
513 
514  viv->n_sb_entries = viv->sb_blocks[viv->current_sb].n_packets;
515 
516  for (i = 0; i < viv->n_sb_entries; i++) {
517  viv->sb_entries[i].size = ffio_read_varlen(pb);
518  viv->sb_entries[i].flag = avio_r8(pb);
519  }
520 
521  ffio_read_varlen(pb);
522  avio_r8(pb);
523 
524  viv->current_sb_entry = 0;
525 }
526 
528 {
529  VividasDemuxContext *viv = s->priv_data;
530  AVIOContext *pb = s->pb;
531  int64_t header_end;
532  int num_tracks;
533  uint32_t key, k2;
534  uint32_t v;
535  uint8_t keybuffer[187];
536  uint32_t b22_size = 0;
537  uint32_t b22_key = 0;
538  uint8_t *buf = 0;
539  int ret;
540 
541  avio_skip(pb, 9);
542 
543  header_end = avio_tell(pb);
544 
545  header_end += ffio_read_varlen(pb);
546 
547  num_tracks = avio_r8(pb);
548 
549  if (num_tracks != 1) {
550  av_log(s, AV_LOG_ERROR, "number of tracks %d is not 1\n", num_tracks);
551  return AVERROR(EINVAL);
552  }
553 
554  v = avio_r8(pb);
555  avio_seek(pb, v, SEEK_CUR);
556 
557  avio_read(pb, keybuffer, 187);
558  key = decode_key(keybuffer);
559  viv->sb_key = key;
560 
561  avio_rl32(pb);
562 
563  for (;;) {
564  int64_t here = avio_tell(pb);
565  int block_len, block_type;
566 
567  if (here >= header_end)
568  break;
569 
570  block_len = ffio_read_varlen(pb);
571  if (avio_feof(pb) || block_len <= 0)
572  return AVERROR_INVALIDDATA;
573 
574  block_type = avio_r8(pb);
575 
576  if (block_type == 22) {
577  avio_read(pb, keybuffer, 187);
578  b22_key = decode_key(keybuffer);
579  b22_size = avio_rl32(pb);
580  }
581 
582  avio_seek(pb, here + block_len, SEEK_SET);
583  }
584 
585  if (b22_size) {
586  k2 = b22_key;
587  buf = read_vblock(pb, &v, b22_key, &k2, 0);
588  if (!buf)
589  return AVERROR(EIO);
590 
591  av_free(buf);
592  }
593 
594  k2 = key;
595  buf = read_vblock(pb, &v, key, &k2, 0);
596  if (!buf)
597  return AVERROR(EIO);
598  ret = track_header(viv, s, buf, v);
599  av_free(buf);
600  if (ret < 0)
601  return ret;
602 
603  buf = read_vblock(pb, &v, key, &k2, v);
604  if (!buf)
605  return AVERROR(EIO);
606  ret = track_index(viv, s, buf, v);
607  av_free(buf);
608  if (ret < 0)
609  goto fail;
610 
611  viv->sb_offset = avio_tell(pb);
612  if (viv->n_sb_blocks > 0) {
613  viv->current_sb = 0;
614  load_sb_block(s, viv, viv->sb_blocks[0].size);
615  } else {
616  viv->current_sb = -1;
617  }
618 
619  return 0;
620 fail:
621  av_freep(&viv->sb_blocks);
622  return ret;
623 }
624 
626  AVPacket *pkt)
627 {
628  VividasDemuxContext *viv = s->priv_data;
629  AVIOContext *pb;
630  int64_t off;
631  int ret;
632 
633  if (!viv->sb_pb)
634  return AVERROR(EIO);
635  if (avio_feof(viv->sb_pb))
636  return AVERROR_EOF;
637 
639  AVStream *astream;
641 
642  pb = viv->sb_pb;
643  ret = av_get_packet(pb, pkt, size);
644  if (ret < 0)
645  return ret;
646  pkt->pos += viv->sb_offset + viv->sb_blocks[viv->current_sb].byte_offset;
647 
648  pkt->stream_index = 1;
649  astream = s->streams[pkt->stream_index];
650 
651  pkt->pts = av_rescale_q(viv->audio_sample, av_make_q(1, astream->codecpar->sample_rate), astream->time_base);
653  pkt->flags |= AV_PKT_FLAG_KEY;
655  return 0;
656  }
657 
658  if (viv->current_sb_entry >= viv->n_sb_entries) {
659  if (viv->current_sb+1 >= viv->n_sb_blocks)
660  return AVERROR(EIO);
661  viv->current_sb++;
662 
663  load_sb_block(s, viv, 0);
664  viv->current_sb_entry = 0;
665  }
666 
667  pb = viv->sb_pb;
668  if (!pb)
669  return AVERROR(EIO);
670  off = avio_tell(pb);
671  off += viv->sb_entries[viv->current_sb_entry].size;
672 
673  if (viv->sb_entries[viv->current_sb_entry].flag == 0) {
674  uint64_t v_size = ffio_read_varlen(pb);
675 
676  if (!viv->num_audio)
677  return AVERROR_INVALIDDATA;
678 
679  ffio_read_varlen(pb);
680  if (v_size > INT_MAX)
681  return AVERROR_INVALIDDATA;
682  ret = av_get_packet(pb, pkt, v_size);
683  if (ret < 0)
684  return ret;
685  pkt->pos += viv->sb_offset + viv->sb_blocks[viv->current_sb].byte_offset;
686 
687  pkt->pts = viv->sb_blocks[viv->current_sb].packet_offset + viv->current_sb_entry;
688  pkt->flags |= (pkt->data[0]&0x80)?0:AV_PKT_FLAG_KEY;
689  pkt->stream_index = 0;
690 
691  for (int i = 0; i < MAX_AUDIO_SUBPACKETS - 1; i++) {
692  int start, pcm_bytes;
693  start = ffio_read_varlen(pb);
694  pcm_bytes = ffio_read_varlen(pb);
695 
696  if (i > 0 && start == 0)
697  break;
698 
699  viv->n_audio_subpackets = i + 1;
700  viv->audio_subpackets[i].start = start;
701  viv->audio_subpackets[i].pcm_bytes = pcm_bytes;
702  }
703  viv->audio_subpackets[viv->n_audio_subpackets].start = (int)(off - avio_tell(pb));
704  viv->current_audio_subpacket = 0;
705 
706  } else {
707  uint64_t v_size = ffio_read_varlen(pb);
708 
709  if (v_size > INT_MAX)
710  return AVERROR_INVALIDDATA;
711  ret = av_get_packet(pb, pkt, v_size);
712  if (ret < 0)
713  return ret;
714  pkt->pos += viv->sb_offset + viv->sb_blocks[viv->current_sb].byte_offset;
715  pkt->pts = viv->sb_blocks[viv->current_sb].packet_offset + viv->current_sb_entry;
716  pkt->flags |= (pkt->data[0] & 0x80) ? 0 : AV_PKT_FLAG_KEY;
717  pkt->stream_index = 0;
718  }
719 
720  viv->current_sb_entry++;
721 
722  return 0;
723 }
724 
726 {
727  VividasDemuxContext *viv = s->priv_data;
728 
729  av_freep(&viv->sb_pb);
730  av_freep(&viv->sb_buf);
731  av_freep(&viv->sb_blocks);
732  av_freep(&viv->sb_entries);
733 
734  return 0;
735 }
736 
737 static int viv_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
738 {
739  VividasDemuxContext *viv = s->priv_data;
740  int64_t frame;
741 
742  if (stream_index == 0)
743  frame = timestamp;
744  else
745  frame = av_rescale_q(timestamp, s->streams[0]->time_base, s->streams[stream_index]->time_base);
746 
747  for (int i = 0; i < viv->n_sb_blocks; i++) {
748  if (frame >= viv->sb_blocks[i].packet_offset && frame < viv->sb_blocks[i].packet_offset + viv->sb_blocks[i].n_packets) {
749  // flush audio packet queue
750  viv->current_audio_subpacket = 0;
751  viv->n_audio_subpackets = 0;
752  viv->current_sb = i;
753  // seek to ith sb block
754  avio_seek(s->pb, viv->sb_offset + viv->sb_blocks[i].byte_offset, SEEK_SET);
755  // load the block
756  load_sb_block(s, viv, 0);
757  // most problematic part: guess audio offset
759  // hand-tuned 1.s a/v offset
760  viv->audio_sample += s->streams[1]->codecpar->sample_rate;
761  viv->current_sb_entry = 0;
762  return 1;
763  }
764  }
765  return 0;
766 }
767 
769  .name = "vividas",
770  .long_name = NULL_IF_CONFIG_SMALL("Vividas VIV"),
771  .priv_data_size = sizeof(VividasDemuxContext),
777 };
#define NULL
Definition: coverity.c:32
uint64_t ffio_read_varlen(AVIOContext *bc)
Definition: aviobuf.c:919
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:1351
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:883
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:1419
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:759
#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:527
#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:737
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:768
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:876
#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:1393
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:1800
int n_packets
Definition: vividas.c:39
static int viv_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: vividas.c:625
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:743
Main libavformat public API header.
int
static void load_sb_block(AVFormatContext *s, VividasDemuxContext *viv, unsigned expected_size)
Definition: vividas.c:483
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:927
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:725
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:1379
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:650
static int track_index(VividasDemuxContext *viv, AVFormatContext *s, uint8_t *buf, unsigned size)
Definition: vividas.c:427
int size
Definition: vividas.c:39
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1023
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:905
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: 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