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