git.sesse.net Git - ffmpeg/blob - libavformat/r3d.c

   1 /*
   2  * R3D REDCODE demuxer
   3  * Copyright (c) 2008 Baptiste Coudurier <baptiste dot coudurier at gmail dot com>
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 //#define DEBUG
  23
  24 #include "libavutil/intreadwrite.h"
  25 #include "libavutil/dict.h"
  26 #include "avformat.h"
  27
  28 typedef struct {
  29     unsigned video_offsets_count;
  30     unsigned *video_offsets;
  31     unsigned rdvo_offset;
  32 } R3DContext;
  33
  34 typedef struct {
  35     unsigned size;
  36     uint32_t tag;
  37     uint64_t offset;
  38 } Atom;
  39
  40 static int read_atom(AVFormatContext *s, Atom *atom)
  41 {
  42     atom->offset = avio_tell(s->pb);
  43     atom->size = avio_rb32(s->pb);
  44     if (atom->size < 8)
  45         return -1;
  46     atom->tag = avio_rl32(s->pb);
  47     av_dlog(s, "atom %u %.4s offset %#"PRIx64"\n",
  48             atom->size, (char*)&atom->tag, atom->offset);
  49     return atom->size;
  50 }
  51
  52 static int r3d_read_red1(AVFormatContext *s)
  53 {
  54     AVStream *st = av_new_stream(s, 0);
  55     char filename[258];
  56     int tmp;
  57     int av_unused tmp2;
  58
  59     if (!st)
  60         return AVERROR(ENOMEM);
  61     st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
  62     st->codec->codec_id = CODEC_ID_JPEG2000;
  63
  64     tmp  = avio_r8(s->pb); // major version
  65     tmp2 = avio_r8(s->pb); // minor version
  66     av_dlog(s, "version %d.%d\n", tmp, tmp2);
  67
  68     tmp = avio_rb16(s->pb); // unknown
  69     av_dlog(s, "unknown1 %d\n", tmp);
  70
  71     tmp = avio_rb32(s->pb);
  72     av_set_pts_info(st, 32, 1, tmp);
  73
  74     tmp = avio_rb32(s->pb); // filenum
  75     av_dlog(s, "filenum %d\n", tmp);
  76
  77     avio_skip(s->pb, 32); // unknown
  78
  79     st->codec->width  = avio_rb32(s->pb);
  80     st->codec->height = avio_rb32(s->pb);
  81
  82     tmp = avio_rb16(s->pb); // unknown
  83     av_dlog(s, "unknown2 %d\n", tmp);
  84
  85     st->codec->time_base.den = avio_rb16(s->pb);
  86     st->codec->time_base.num = avio_rb16(s->pb);
  87
  88     tmp = avio_r8(s->pb); // audio channels
  89     av_dlog(s, "audio channels %d\n", tmp);
  90     if (tmp > 0) {
  91         AVStream *ast = av_new_stream(s, 1);
  92         if (!ast)
  93             return AVERROR(ENOMEM);
  94         ast->codec->codec_type = AVMEDIA_TYPE_AUDIO;
  95         ast->codec->codec_id = CODEC_ID_PCM_S32BE;
  96         ast->codec->channels = tmp;
  97         av_set_pts_info(ast, 32, 1, st->time_base.den);
  98     }
  99
 100     avio_read(s->pb, filename, 257);
 101     filename[sizeof(filename)-1] = 0;
 102     av_dict_set(&st->metadata, "filename", filename, 0);
 103
 104     av_dlog(s, "filename %s\n", filename);
 105     av_dlog(s, "resolution %dx%d\n", st->codec->width, st->codec->height);
 106     av_dlog(s, "timescale %d\n", st->time_base.den);
 107     av_dlog(s, "frame rate %d/%d\n",
 108             st->codec->time_base.num, st->codec->time_base.den);
 109
 110     return 0;
 111 }
 112
 113 static int r3d_read_rdvo(AVFormatContext *s, Atom *atom)
 114 {
 115     R3DContext *r3d = s->priv_data;
 116     AVStream *st = s->streams[0];
 117     int i;
 118
 119     r3d->video_offsets_count = (atom->size - 8) / 4;
 120     r3d->video_offsets = av_malloc(atom->size);
 121     if (!r3d->video_offsets)
 122         return AVERROR(ENOMEM);
 123
 124     for (i = 0; i < r3d->video_offsets_count; i++) {
 125         r3d->video_offsets[i] = avio_rb32(s->pb);
 126         if (!r3d->video_offsets[i]) {
 127             r3d->video_offsets_count = i;
 128             break;
 129         }
 130         av_dlog(s, "video offset %d: %#x\n", i, r3d->video_offsets[i]);
 131     }
 132
 133     if (st->codec->time_base.den)
 134         st->duration = (uint64_t)r3d->video_offsets_count*
 135             st->time_base.den*st->codec->time_base.num/st->codec->time_base.den;
 136     av_dlog(s, "duration %"PRId64"\n", st->duration);
 137
 138     return 0;
 139 }
 140
 141 static void r3d_read_reos(AVFormatContext *s)
 142 {
 143     R3DContext *r3d = s->priv_data;
 144     int av_unused tmp;
 145
 146     r3d->rdvo_offset = avio_rb32(s->pb);
 147     avio_rb32(s->pb); // rdvs offset
 148     avio_rb32(s->pb); // rdao offset
 149     avio_rb32(s->pb); // rdas offset
 150
 151     tmp = avio_rb32(s->pb);
 152     av_dlog(s, "num video chunks %d\n", tmp);
 153
 154     tmp = avio_rb32(s->pb);
 155     av_dlog(s, "num audio chunks %d\n", tmp);
 156
 157     avio_skip(s->pb, 6*4);
 158 }
 159
 160 static int r3d_read_header(AVFormatContext *s, AVFormatParameters *ap)
 161 {
 162     R3DContext *r3d = s->priv_data;
 163     Atom atom;
 164     int ret;
 165
 166     if (read_atom(s, &atom) < 0) {
 167         av_log(s, AV_LOG_ERROR, "error reading atom\n");
 168         return -1;
 169     }
 170     if (atom.tag == MKTAG('R','E','D','1')) {
 171         if ((ret = r3d_read_red1(s)) < 0) {
 172             av_log(s, AV_LOG_ERROR, "error parsing 'red1' atom\n");
 173             return ret;
 174         }
 175     } else {
 176         av_log(s, AV_LOG_ERROR, "could not find 'red1' atom\n");
 177         return -1;
 178     }
 179
 180     s->data_offset = avio_tell(s->pb);
 181     av_dlog(s, "data offset %#"PRIx64"\n", s->data_offset);
 182     if (!s->pb->seekable)
 183         return 0;
 184     // find REOB/REOF/REOS to load index
 185     avio_seek(s->pb, avio_size(s->pb)-48-8, SEEK_SET);
 186     if (read_atom(s, &atom) < 0)
 187         av_log(s, AV_LOG_ERROR, "error reading end atom\n");
 188
 189     if (atom.tag != MKTAG('R','E','O','B') &&
 190         atom.tag != MKTAG('R','E','O','F') &&
 191         atom.tag != MKTAG('R','E','O','S'))
 192         goto out;
 193
 194     r3d_read_reos(s);
 195
 196     if (r3d->rdvo_offset) {
 197         avio_seek(s->pb, r3d->rdvo_offset, SEEK_SET);
 198         if (read_atom(s, &atom) < 0)
 199             av_log(s, AV_LOG_ERROR, "error reading 'rdvo' atom\n");
 200         if (atom.tag == MKTAG('R','D','V','O')) {
 201             if (r3d_read_rdvo(s, &atom) < 0)
 202                 av_log(s, AV_LOG_ERROR, "error parsing 'rdvo' atom\n");
 203         }
 204     }
 205
 206  out:
 207     avio_seek(s->pb, s->data_offset, SEEK_SET);
 208     return 0;
 209 }
 210
 211 static int r3d_read_redv(AVFormatContext *s, AVPacket *pkt, Atom *atom)
 212 {
 213     AVStream *st = s->streams[0];
 214     int tmp;
 215     int av_unused tmp2;
 216     uint64_t pos = avio_tell(s->pb);
 217     unsigned dts;
 218     int ret;
 219
 220     dts = avio_rb32(s->pb);
 221
 222     tmp = avio_rb32(s->pb);
 223     av_dlog(s, "frame num %d\n", tmp);
 224
 225     tmp  = avio_r8(s->pb); // major version
 226     tmp2 = avio_r8(s->pb); // minor version
 227     av_dlog(s, "version %d.%d\n", tmp, tmp2);
 228
 229     tmp = avio_rb16(s->pb); // unknown
 230     av_dlog(s, "unknown %d\n", tmp);
 231
 232     if (tmp > 4) {
 233         tmp = avio_rb16(s->pb); // unknown
 234         av_dlog(s, "unknown %d\n", tmp);
 235
 236         tmp = avio_rb16(s->pb); // unknown
 237         av_dlog(s, "unknown %d\n", tmp);
 238
 239         tmp = avio_rb32(s->pb);
 240         av_dlog(s, "width %d\n", tmp);
 241         tmp = avio_rb32(s->pb);
 242         av_dlog(s, "height %d\n", tmp);
 243
 244         tmp = avio_rb32(s->pb);
 245         av_dlog(s, "metadata len %d\n", tmp);
 246     }
 247     tmp = atom->size - 8 - (avio_tell(s->pb) - pos);
 248     if (tmp < 0)
 249         return -1;
 250     ret = av_get_packet(s->pb, pkt, tmp);
 251     if (ret < 0) {
 252         av_log(s, AV_LOG_ERROR, "error reading video packet\n");
 253         return -1;
 254     }
 255
 256     pkt->stream_index = 0;
 257     pkt->dts = dts;
 258     if (st->codec->time_base.den)
 259         pkt->duration = (uint64_t)st->time_base.den*
 260             st->codec->time_base.num/st->codec->time_base.den;
 261     av_dlog(s, "pkt dts %"PRId64" duration %d\n", pkt->dts, pkt->duration);
 262
 263     return 0;
 264 }
 265
 266 static int r3d_read_reda(AVFormatContext *s, AVPacket *pkt, Atom *atom)
 267 {
 268     AVStream *st = s->streams[1];
 269     int av_unused tmp, tmp2;
 270     int samples, size;
 271     uint64_t pos = avio_tell(s->pb);
 272     unsigned dts;
 273     int ret;
 274
 275     dts = avio_rb32(s->pb);
 276
 277     st->codec->sample_rate = avio_rb32(s->pb);
 278
 279     samples = avio_rb32(s->pb);
 280
 281     tmp = avio_rb32(s->pb);
 282     av_dlog(s, "packet num %d\n", tmp);
 283
 284     tmp = avio_rb16(s->pb); // unkown
 285     av_dlog(s, "unknown %d\n", tmp);
 286
 287     tmp  = avio_r8(s->pb); // major version
 288     tmp2 = avio_r8(s->pb); // minor version
 289     av_dlog(s, "version %d.%d\n", tmp, tmp2);
 290
 291     tmp = avio_rb32(s->pb); // unknown
 292     av_dlog(s, "unknown %d\n", tmp);
 293
 294     size = atom->size - 8 - (avio_tell(s->pb) - pos);
 295     if (size < 0)
 296         return -1;
 297     ret = av_get_packet(s->pb, pkt, size);
 298     if (ret < 0) {
 299         av_log(s, AV_LOG_ERROR, "error reading audio packet\n");
 300         return ret;
 301     }
 302
 303     pkt->stream_index = 1;
 304     pkt->dts = dts;
 305     pkt->duration = av_rescale(samples, st->time_base.den, st->codec->sample_rate);
 306     av_dlog(s, "pkt dts %"PRId64" duration %d samples %d sample rate %d\n",
 307             pkt->dts, pkt->duration, samples, st->codec->sample_rate);
 308
 309     return 0;
 310 }
 311
 312 static int r3d_read_packet(AVFormatContext *s, AVPacket *pkt)
 313 {
 314     Atom atom;
 315     int err = 0;
 316
 317     while (!err) {
 318         if (read_atom(s, &atom) < 0) {
 319             err = -1;
 320             break;
 321         }
 322         switch (atom.tag) {
 323         case MKTAG('R','E','D','V'):
 324             if (s->streams[0]->discard == AVDISCARD_ALL)
 325                 goto skip;
 326             if (!(err = r3d_read_redv(s, pkt, &atom)))
 327                 return 0;
 328             break;
 329         case MKTAG('R','E','D','A'):
 330             if (s->nb_streams < 2)
 331                 return -1;
 332             if (s->streams[1]->discard == AVDISCARD_ALL)
 333                 goto skip;
 334             if (!(err = r3d_read_reda(s, pkt, &atom)))
 335                 return 0;
 336             break;
 337         default:
 338         skip:
 339             avio_skip(s->pb, atom.size-8);
 340         }
 341     }
 342     return err;
 343 }
 344
 345 static int r3d_probe(AVProbeData *p)
 346 {
 347     if (AV_RL32(p->buf + 4) == MKTAG('R','E','D','1'))
 348         return AVPROBE_SCORE_MAX;
 349     return 0;
 350 }
 351
 352 static int r3d_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags)
 353 {
 354     AVStream *st = s->streams[0]; // video stream
 355     R3DContext *r3d = s->priv_data;
 356     int frame_num;
 357
 358     if (!st->codec->time_base.num || !st->time_base.den)
 359         return -1;
 360
 361     frame_num = sample_time*st->codec->time_base.den/
 362         ((int64_t)st->codec->time_base.num*st->time_base.den);
 363     av_dlog(s, "seek frame num %d timestamp %"PRId64"\n",
 364             frame_num, sample_time);
 365
 366     if (frame_num < r3d->video_offsets_count) {
 367         avio_seek(s->pb, r3d->video_offsets_count, SEEK_SET);
 368     } else {
 369         av_log(s, AV_LOG_ERROR, "could not seek to frame %d\n", frame_num);
 370         return -1;
 371     }
 372
 373     return 0;
 374 }
 375
 376 static int r3d_close(AVFormatContext *s)
 377 {
 378     R3DContext *r3d = s->priv_data;
 379
 380     av_freep(&r3d->video_offsets);
 381
 382     return 0;
 383 }
 384
 385 AVInputFormat ff_r3d_demuxer = {
 386     "r3d",
 387     NULL_IF_CONFIG_SMALL("REDCODE R3D format"),
 388     sizeof(R3DContext),
 389     r3d_probe,
 390     r3d_read_header,
 391     r3d_read_packet,
 392     r3d_close,
 393     r3d_seek,
 394 };