Merge commit 'fcc455ff2e11ed04603aead1984a92ac3a4be226'
authorMichael Niedermayer <michaelni@gmx.at>
Tue, 6 Aug 2013 16:01:03 +0000 (18:01 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Tue, 6 Aug 2013 16:01:03 +0000 (18:01 +0200)
* commit 'fcc455ff2e11ed04603aead1984a92ac3a4be226':
  avformat/dv: K&R formatting cosmetics

Conflicts:
libavformat/dv.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavformat/dv.c

diff --combined libavformat/dv.c
index a04735ac25263ccc671b18f2113f0f128e1be121,d52be5d5a590d7765a026273297e8804fe1cb57d..cc48f483eb8e678ef0db69edafbbedb7fa5d102a
   * Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com>
   * Funded by BBC Research & Development
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  #include <time.h>
@@@ -36,9 -36,7 +36,9 @@@
  #include "libavutil/channel_layout.h"
  #include "libavutil/intreadwrite.h"
  #include "libavutil/mathematics.h"
 +#include "libavutil/timecode.h"
  #include "dv.h"
 +#include "libavutil/avassert.h"
  
  struct DVDemuxContext {
      const DVprofile*  sys;    /* Current DV profile. E.g.: 525/60, 625/50 */
@@@ -65,7 -63,7 +65,7 @@@ static inline uint16_t dv_audio_12to16(
          shift--;
          result = (sample - (256 * shift)) << shift;
      } else {
-         shift = 0xe - shift;
+         shift  = 0xe - shift;
          result = ((sample + ((256 * shift) + 1)) << shift) - 1;
      }
  
   * a fixed offset and if pack isn't there -- fails. We might want
   * to have a fallback mechanism for complete search of missing packs.
   */
- static const uint8_t* dv_extract_pack(uint8_t* frame, enum dv_pack_type t)
+ static const uint8_t *dv_extract_pack(uint8_t *frame, enum dv_pack_type t)
  {
      int offs;
  
      switch (t) {
      case dv_audio_source:
-         offs = (80*6 + 80*16*3 + 3);
+         offs = (80 * 6 + 80 * 16 * 3 + 3);
          break;
      case dv_audio_control:
-         offs = (80*6 + 80*16*4 + 3);
+         offs = (80 * 6 + 80 * 16 * 4 + 3);
          break;
      case dv_video_control:
-         offs = (80*5 + 48 + 5);
+         offs = (80 * 5 + 48 + 5);
          break;
 +    case dv_timecode:
 +        offs = (80*1 + 3 + 3);
 +        break;
      default:
          return NULL;
      }
@@@ -113,43 -108,38 +113,43 @@@ static const int dv_audio_frequency[3] 
   * 3. Audio is always returned as 16bit linear samples: 12bit nonlinear samples
   *    are converted into 16bit linear ones.
   */
- static int dv_extract_audio(uint8_t* frame, uint8_t* ppcm[4],
+ static int dv_extract_audio(uint8_t *frame, uint8_t *ppcm[4],
                              const DVprofile *sys)
  {
      int size, chan, i, j, d, of, smpls, freq, quant, half_ch;
      uint16_t lc, rc;
-     const uint8_tas_pack;
+     const uint8_t *as_pack;
      uint8_t *pcm, ipcm;
  
      as_pack = dv_extract_pack(frame, dv_audio_source);
      if (!as_pack)    /* No audio ? */
          return 0;
  
-     smpls =  as_pack[1] & 0x3f;       /* samples in this frame - min. samples */
-     freq  = (as_pack[4] >> 3) & 0x07; /* 0 - 48kHz, 1 - 44,1kHz, 2 - 32kHz */
-     quant =  as_pack[4] & 0x07;       /* 0 - 16bit linear, 1 - 12bit nonlinear */
+     smpls = as_pack[1]      & 0x3f; /* samples in this frame - min. samples */
+     freq  = as_pack[4] >> 3 & 0x07; /* 0 - 48kHz, 1 - 44,1kHz, 2 - 32kHz */
+     quant = as_pack[4]      & 0x07; /* 0 - 16bit linear, 1 - 12bit nonlinear */
  
      if (quant > 1)
-         return -1; /* unsupported quantization */
+         return -1;  /* unsupported quantization */
  
      if (freq >= FF_ARRAY_ELEMS(dv_audio_frequency))
          return AVERROR_INVALIDDATA;
  
-     size = (sys->audio_min_samples[freq] + smpls) * 4; /* 2ch, 2bytes */
+     size    = (sys->audio_min_samples[freq] + smpls) * 4; /* 2ch, 2bytes */
      half_ch = sys->difseg_size / 2;
  
      /* We work with 720p frames split in half, thus even frames have
       * channels 0,1 and odd 2,3. */
      ipcm = (sys->height == 720 && !(frame[1] & 0x0C)) ? 2 : 0;
  
 +    if (ipcm + sys->n_difchan > (quant == 1 ? 2 : 4)) {
 +        av_log(NULL, AV_LOG_ERROR, "too many dv pcm frames\n");
 +        return AVERROR_INVALIDDATA;
 +    }
 +
      /* for each DIF channel */
      for (chan = 0; chan < sys->n_difchan; chan++) {
 -        /* next stereo channel (50Mbps and 100Mbps only) */
 +        av_assert0(ipcm<4);
          pcm = ppcm[ipcm++];
          if (!pcm)
              break;
              frame += 6 * 80; /* skip DIF segment header */
              if (quant == 1 && i == half_ch) {
                  /* next stereo channel (12bit mode only) */
 +                av_assert0(ipcm<4);
                  pcm = ppcm[ipcm++];
                  if (!pcm)
                      break;
              for (j = 0; j < 9; j++) {
                  for (d = 8; d < 80; d += 2) {
                      if (quant == 0) {  /* 16bit quantization */
-                         of = sys->audio_shuffle[i][j] + (d - 8) / 2 * sys->audio_stride;
-                         if (of*2 >= size)
+                         of = sys->audio_shuffle[i][j] +
+                              (d - 8) / 2 * sys->audio_stride;
+                         if (of * 2 >= size)
                              continue;
  
-                         pcm[of*2]   = frame[d+1]; // FIXME: maybe we have to admit
-                         pcm[of*2+1] = frame[d];   //        that DV is a big-endian PCM
-                         if (pcm[of*2+1] == 0x80 && pcm[of*2] == 0x00)
-                             pcm[of*2+1] = 0;
+                         /* FIXME: maybe we have to admit that DV is a
+                          * big-endian PCM */
+                         pcm[of * 2]     = frame[d + 1];
+                         pcm[of * 2 + 1] = frame[d];
+                         if (pcm[of * 2 + 1] == 0x80 && pcm[of * 2] == 0x00)
+                             pcm[of * 2 + 1] = 0;
                      } else {           /* 12bit quantization */
-                         lc = ((uint16_t)frame[d]   << 4) |
-                              ((uint16_t)frame[d+2] >> 4);
-                         rc = ((uint16_t)frame[d+1] << 4) |
-                              ((uint16_t)frame[d+2] & 0x0f);
+                         lc = ((uint16_t)frame[d]     << 4) |
+                              ((uint16_t)frame[d + 2] >> 4);
+                         rc = ((uint16_t)frame[d + 1] << 4) |
+                              ((uint16_t)frame[d + 2] & 0x0f);
                          lc = (lc == 0x800 ? 0 : dv_audio_12to16(lc));
                          rc = (rc == 0x800 ? 0 : dv_audio_12to16(rc));
  
-                         of = sys->audio_shuffle[i%half_ch][j] + (d - 8) / 3 * sys->audio_stride;
-                         if (of*2 >= size)
+                         of = sys->audio_shuffle[i % half_ch][j] +
+                              (d - 8) / 3 * sys->audio_stride;
+                         if (of * 2 >= size)
                              continue;
  
-                         pcm[of*2]   = lc & 0xff; // FIXME: maybe we have to admit
-                         pcm[of*2+1] = lc >> 8;   //        that DV is a big-endian PCM
-                         of = sys->audio_shuffle[i%half_ch+half_ch][j] +
-                             (d - 8) / 3 * sys->audio_stride;
-                         pcm[of*2]   = rc & 0xff; // FIXME: maybe we have to admit
-                         pcm[of*2+1] = rc >> 8;   //        that DV is a big-endian PCM
+                         /* FIXME: maybe we have to admit that DV is a
+                          * big-endian PCM */
+                         pcm[of * 2]     = lc & 0xff;
+                         pcm[of * 2 + 1] = lc >> 8;
+                         of = sys->audio_shuffle[i % half_ch + half_ch][j] +
+                              (d - 8) / 3 * sys->audio_stride;
+                         /* FIXME: maybe we have to admit that DV is a
+                          * big-endian PCM */
+                         pcm[of * 2]     = rc & 0xff;
+                         pcm[of * 2 + 1] = rc >> 8;
                          ++d;
                      }
                  }
      return size;
  }
  
- static int dv_extract_audio_info(DVDemuxContext* c, uint8_t* frame)
+ static int dv_extract_audio_info(DVDemuxContext *c, uint8_t *frame)
  {
-     const uint8_tas_pack;
+     const uint8_t *as_pack;
      int freq, stype, smpls, quant, i, ach;
  
      as_pack = dv_extract_pack(frame, dv_audio_source);
          return 0;
      }
  
-     smpls =  as_pack[1] & 0x3f;       /* samples in this frame - min. samples */
-     freq  = (as_pack[4] >> 3) & 0x07; /* 0 - 48kHz, 1 - 44,1kHz, 2 - 32kHz */
-     stype = (as_pack[3] & 0x1f);      /* 0 - 2CH, 2 - 4CH, 3 - 8CH */
-     quant =  as_pack[4] & 0x07;       /* 0 - 16bit linear, 1 - 12bit nonlinear */
+     smpls = as_pack[1]      & 0x3f; /* samples in this frame - min. samples */
+     freq  = as_pack[4] >> 3 & 0x07; /* 0 - 48kHz, 1 - 44,1kHz, 2 - 32kHz */
+     stype = as_pack[3]      & 0x1f; /* 0 - 2CH, 2 - 4CH, 3 - 8CH */
+     quant = as_pack[4]      & 0x07; /* 0 - 16bit linear, 1 - 12bit nonlinear */
  
      if (freq >= FF_ARRAY_ELEMS(dv_audio_frequency)) {
          av_log(c->fctx, AV_LOG_ERROR,
      }
  
      /* note: ach counts PAIRS of channels (i.e. stereo channels) */
-     ach = ((int[4]){  1,  0,  2,  4})[stype];
+     ach = ((int[4]) { 1, 0, 2, 4 })[stype];
      if (ach == 1 && quant && freq == 2)
          ach = 2;
  
              c->audio_pkt[i].stream_index = c->ast[i]->index;
              c->audio_pkt[i].flags       |= AV_PKT_FLAG_KEY;
          }
-         c->ast[i]->codec->sample_rate = dv_audio_frequency[freq];
-         c->ast[i]->codec->channels    = 2;
+         c->ast[i]->codec->sample_rate    = dv_audio_frequency[freq];
+         c->ast[i]->codec->channels       = 2;
          c->ast[i]->codec->channel_layout = AV_CH_LAYOUT_STEREO;
-         c->ast[i]->codec->bit_rate    = 2 * dv_audio_frequency[freq] * 16;
-         c->ast[i]->start_time         = 0;
+         c->ast[i]->codec->bit_rate       = 2 * dv_audio_frequency[freq] * 16;
+         c->ast[i]->start_time            = 0;
      }
      c->ach = i;
  
-     return (c->sys->audio_min_samples[freq] + smpls) * 4; /* 2ch, 2bytes */;
+     return (c->sys->audio_min_samples[freq] + smpls) * 4; /* 2ch, 2bytes */
  }
  
- static int dv_extract_video_info(DVDemuxContext *c, uint8_tframe)
+ static int dv_extract_video_info(DVDemuxContext *c, uint8_t *frame)
  {
-     const uint8_tvsc_pack;
-     AVCodecContextavctx;
+     const uint8_t *vsc_pack;
+     AVCodecContext *avctx;
      int apt, is16_9;
      int size = 0;
  
  
          avpriv_set_pts_info(c->vst, 64, c->sys->time_base.num,
                              c->sys->time_base.den);
-         avctx->time_base= c->sys->time_base;
+         avctx->time_base = c->sys->time_base;
 -        if (!avctx->width) {
 -            avctx->width  = c->sys->width;
 -            avctx->height = c->sys->height;
 -        }
 -        avctx->pix_fmt = c->sys->pix_fmt;
  
          /* finding out SAR is a little bit messy */
          vsc_pack = dv_extract_pack(frame, dv_video_control);
          is16_9   = (vsc_pack && ((vsc_pack[2] & 0x07) == 0x02 ||
                                   (!apt && (vsc_pack[2] & 0x07) == 0x07)));
          c->vst->sample_aspect_ratio = c->sys->sar[is16_9];
-         avctx->bit_rate = av_rescale_q(c->sys->frame_size, (AVRational){8,1},
+         avctx->bit_rate = av_rescale_q(c->sys->frame_size,
+                                        (AVRational) { 8, 1 },
                                         c->sys->time_base);
          size = c->sys->frame_size;
      }
      return size;
  }
  
- /*
-  * The following 3 functions constitute our interface to the world
-  */
 +static int dv_extract_timecode(DVDemuxContext* c, uint8_t* frame, char *tc)
 +{
 +    const uint8_t *tc_pack;
 +
 +    // For PAL systems, drop frame bit is replaced by an arbitrary
 +    // bit so its value should not be considered. Drop frame timecode
 +    // is only relevant for NTSC systems.
 +    int prevent_df = c->sys->ltc_divisor == 25 || c->sys->ltc_divisor == 50;
 +
 +    tc_pack = dv_extract_pack(frame, dv_timecode);
 +    if (!tc_pack)
 +        return 0;
 +    av_timecode_make_smpte_tc_string(tc, AV_RB32(tc_pack + 1), prevent_df);
 +    return 1;
 +}
 +
+ /* The following 3 functions constitute our interface to the world */
  
- DVDemuxContextavpriv_dv_init_demux(AVFormatContext *s)
+ DVDemuxContext *avpriv_dv_init_demux(AVFormatContext *s)
  {
      DVDemuxContext *c;
  
@@@ -344,9 -330,9 +352,9 @@@ int avpriv_dv_get_packet(DVDemuxContex
  
      for (i = 0; i < c->ach; i++) {
          if (c->ast[i] && c->audio_pkt[i].size) {
-             *pkt = c->audio_pkt[i];
+             *pkt                 = c->audio_pkt[i];
              c->audio_pkt[i].size = 0;
-             size = pkt->size;
+             size                 = pkt->size;
              break;
          }
      }
  }
  
  int avpriv_dv_produce_packet(DVDemuxContext *c, AVPacket *pkt,
-                       uint8_t* buf, int buf_size, int64_t pos)
 -                             uint8_t *buf, int buf_size)
++                             uint8_t *buf, int buf_size, int64_t pos)
  {
      int size, i;
-     uint8_t *ppcm[4] = {0};
+     uint8_t *ppcm[4] = { 0 };
  
      if (buf_size < DV_PROFILE_BYTES ||
          !(c->sys = avpriv_dv_frame_profile(c->sys, buf, buf_size)) ||
      /* FIXME: in case of no audio/bad audio we have to do something */
      size = dv_extract_audio_info(c, buf);
      for (i = 0; i < c->ach; i++) {
 +        c->audio_pkt[i].pos  = pos;
          c->audio_pkt[i].size = size;
-         c->audio_pkt[i].pts  = c->abytes * 30000 * 8 / c->ast[i]->codec->bit_rate;
+         c->audio_pkt[i].pts  = c->abytes * 30000 * 8 /
+                                c->ast[i]->codec->bit_rate;
          ppcm[i] = c->audio_buf[i];
      }
      if (c->ach)
              c->audio_pkt[2].size = c->audio_pkt[3].size = 0;
          } else {
              c->audio_pkt[0].size = c->audio_pkt[1].size = 0;
-             c->abytes += size;
+             c->abytes           += size;
          }
      } else {
          c->abytes += size;
      size = dv_extract_video_info(c, buf);
      av_init_packet(pkt);
      pkt->data         = buf;
 +    pkt->pos          = pos;
      pkt->size         = size;
      pkt->flags       |= AV_PKT_FLAG_KEY;
      pkt->stream_index = c->vst->index;
  }
  
  static int64_t dv_frame_offset(AVFormatContext *s, DVDemuxContext *c,
-                               int64_t timestamp, int flags)
+                                int64_t timestamp, int flags)
  {
      // FIXME: sys may be wrong if last dv_read_packet() failed (buffer is junk)
-     const DVprofilesys = avpriv_dv_codec_profile(c->vst->codec);
+     const DVprofile *sys = avpriv_dv_codec_profile(c->vst->codec);
      int64_t offset;
-     int64_t size = avio_size(s->pb) - s->data_offset;
-     int64_t max_offset = ((size-1) / sys->frame_size) * sys->frame_size;
+     int64_t size       = avio_size(s->pb) - s->data_offset;
+     int64_t max_offset = ((size - 1) / sys->frame_size) * sys->frame_size;
  
      offset = sys->frame_size * timestamp;
  
-     if (size >= 0 && offset > max_offset) offset = max_offset;
-     else if (offset < 0) offset = 0;
+     if (size >= 0 && offset > max_offset)
+         offset = max_offset;
+     else if (offset < 0)
+         offset = 0;
  
      return offset + s->data_offset;
  }
  
  void ff_dv_offset_reset(DVDemuxContext *c, int64_t frame_offset)
  {
-     c->frames= frame_offset;
+     c->frames = frame_offset;
 -    if (c->ach)
 +    if (c->ach) {
 +        if (c->sys) {
-         c->abytes= av_rescale_q(c->frames, c->sys->time_base,
-                                 (AVRational){8, c->ast[0]->codec->bit_rate});
-         }else
+         c->abytes = av_rescale_q(c->frames, c->sys->time_base,
+                                  (AVRational) { 8, c->ast[0]->codec->bit_rate });
 -
++        } else
 +            av_log(c->fctx, AV_LOG_ERROR, "cannot adjust audio bytes\n");
 +    }
      c->audio_pkt[0].size = c->audio_pkt[1].size = 0;
      c->audio_pkt[2].size = c->audio_pkt[3].size = 0;
  }
   ************************************************************/
  
  typedef struct RawDVContext {
-     DVDemuxContextdv_demux;
+     DVDemuxContext *dv_demux;
      uint8_t         buf[DV_MAX_FRAME_SIZE];
  } RawDVContext;
  
 +static int dv_read_timecode(AVFormatContext *s) {
 +    int ret;
 +    char timecode[AV_TIMECODE_STR_SIZE];
 +    int64_t pos = avio_tell(s->pb);
 +
 +    // Read 3 DIF blocks: Header block and 2 Subcode blocks.
 +    int partial_frame_size = 3 * 80;
 +    uint8_t *partial_frame = av_mallocz(sizeof(*partial_frame) *
 +                                        partial_frame_size);
 +
 +    RawDVContext *c = s->priv_data;
 +    ret = avio_read(s->pb, partial_frame, partial_frame_size);
 +    if (ret < 0)
 +        goto finish;
 +
 +    if (ret < partial_frame_size) {
 +        ret = -1;
 +        goto finish;
 +    }
 +
 +    ret = dv_extract_timecode(c->dv_demux, partial_frame, timecode);
 +    if (ret)
 +        av_dict_set(&s->metadata, "timecode", timecode, 0);
 +    else
 +        av_log(s, AV_LOG_ERROR, "Detected timecode is invalid\n");
 +
 +finish:
 +    av_free(partial_frame);
 +    avio_seek(s->pb, pos, SEEK_SET);
 +    return ret;
 +}
 +
  static int dv_read_header(AVFormatContext *s)
  {
      unsigned state, marker_pos = 0;
  
      state = avio_rb32(s->pb);
      while ((state & 0xffffff7f) != 0x1f07003f) {
 -        if (s->pb->eof_reached) {
 +        if (url_feof(s->pb)) {
              av_log(s, AV_LOG_ERROR, "Cannot find DV header.\n");
              return -1;
          }
      }
      AV_WB32(c->buf, state);
  
 -    if (avio_read(s->pb, c->buf + 4, DV_PROFILE_BYTES - 4) <= 0 ||
 +    if (avio_read(s->pb, c->buf + 4, DV_PROFILE_BYTES - 4) != DV_PROFILE_BYTES - 4 ||
          avio_seek(s->pb, -DV_PROFILE_BYTES, SEEK_CUR) < 0)
          return AVERROR(EIO);
  
-     c->dv_demux->sys = avpriv_dv_frame_profile(c->dv_demux->sys, c->buf, DV_PROFILE_BYTES);
+     c->dv_demux->sys = avpriv_dv_frame_profile(c->dv_demux->sys,
+                                                c->buf,
+                                                DV_PROFILE_BYTES);
      if (!c->dv_demux->sys) {
-         av_log(s, AV_LOG_ERROR, "Can't determine profile of DV input stream.\n");
+         av_log(s, AV_LOG_ERROR,
+                "Can't determine profile of DV input stream.\n");
          return -1;
      }
  
-     s->bit_rate = av_rescale_q(c->dv_demux->sys->frame_size, (AVRational){8,1},
+     s->bit_rate = av_rescale_q(c->dv_demux->sys->frame_size,
+                                (AVRational) { 8, 1 },
                                 c->dv_demux->sys->time_base);
  
 +    if (s->pb->seekable)
 +        dv_read_timecode(s);
 +
      return 0;
  }
  
  static int dv_read_packet(AVFormatContext *s, AVPacket *pkt)
  {
      int size;
      size = avpriv_dv_get_packet(c->dv_demux, pkt);
  
      if (size < 0) {
 +        int64_t pos = avio_tell(s->pb);
          if (!c->dv_demux->sys)
              return AVERROR(EIO);
          size = c->dv_demux->sys->frame_size;
          if (avio_read(s->pb, c->buf, size) <= 0)
              return AVERROR(EIO);
  
 -        size = avpriv_dv_produce_packet(c->dv_demux, pkt, c->buf, size);
 +        size = avpriv_dv_produce_packet(c->dv_demux, pkt, c->buf, size, pos);
      }
  
      return size;
  }
  
  static int dv_read_seek(AVFormatContext *s, int stream_index,
-                        int64_t timestamp, int flags)
+                         int64_t timestamp, int flags)
  {
      RawDVContext *r   = s->priv_data;
      DVDemuxContext *c = r->dv_demux;
@@@ -570,7 -521,7 +584,7 @@@ static int dv_probe(AVProbeData *p
  {
      unsigned state, marker_pos = 0;
      int i;
-     int matches = 0;
+     int matches           = 0;
      int secondary_matches = 0;
  
      if (p->buf_size < 5)
          state = (state << 8) | p->buf[i];
      }
  
-     if (matches && p->buf_size / matches < 1024*1024) {
-         if (matches > 4 || (secondary_matches >= 10 && p->buf_size / secondary_matches < 24000))
-             return AVPROBE_SCORE_MAX*3/4; // not max to avoid dv in mov to match
-         return AVPROBE_SCORE_MAX/4;
+     if (matches && p->buf_size / matches < 1024 * 1024) {
+         if (matches > 4 ||
+             (secondary_matches >= 10 &&
+              p->buf_size / secondary_matches < 24000))
+             // not max to avoid dv in mov to match
+             return AVPROBE_SCORE_MAX * 3 / 4;
+         return AVPROBE_SCORE_MAX / 4;
      }
      return 0;
  }