Added AVFormatFlag strings

sys/ffmpeg61/avcodec_parameters.go

@@ -17,43 +17,62 @@ import "C"
 ////////////////////////////////////////////////////////////////////////////////
 // TYPES
 
+type jsonAVCodecParametersAudio struct {
+	SampleFormat  AVSampleFormat  `json:"format,omitempty"`
+	SampleRate    int             `json:"sample_rate,omitempty"`
+	ChannelLayout AVChannelLayout `json:"channel_layout,omitempty"`
+	FrameSize     int             `json:"frame_size,omitempty"`
+}
+
+type jsonAVCodecParameterVideo struct {
+	PixelFormat       AVPixelFormat `json:"format,omitempty"`
+	Width             int           `json:"width,omitempty"`
+	Height            int           `json:"height,omitempty"`
+	SampleAspectRatio AVRational    `json:"sample_aspect_ratio,omitempty"`
+}
+
 type jsonAVCodecParameters struct {
-	CodecType         AVMediaType `json:"codec_type"`
-	CodecID           AVCodecID   `json:"codec_id,omitempty"`
-	CodecTag          uint32      `json:"codec_tag,omitempty"`
-	Format            int         `json:"format,omitempty"`
-	BitRate           int64       `json:"bit_rate,omitempty"`
-	Width             int         `json:"width,omitempty"`
-	Height            int         `json:"height,omitempty"`
-	SampleAspectRatio AVRational  `json:"sample_aspect_ratio,omitempty"`
-	SampleRate        int         `json:"sample_rate,omitempty"`
-	FrameSize         int         `json:"frame_size,omitempty"`
+	CodecType AVMediaType `json:"codec_type"`
+	CodecID   AVCodecID   `json:"codec_id,omitempty"`
+	CodecTag  uint32      `json:"codec_tag,omitempty"`
+	BitRate   int64       `json:"bit_rate,omitempty"`
+	*jsonAVCodecParametersAudio
+	*jsonAVCodecParameterVideo
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // STRINGIFY
 
 func (ctx *AVCodecParameters) MarshalJSON() ([]byte, error) {
-	return json.Marshal(jsonAVCodecParameters{
-		CodecType:         AVMediaType(ctx.codec_type),
-		CodecID:           AVCodecID(ctx.codec_id),
-		CodecTag:          uint32(ctx.codec_tag),
-		Format:            int(ctx.format),
-		BitRate:           int64(ctx.bit_rate),
-		Width:             int(ctx.width),
-		Height:            int(ctx.height),
-		SampleAspectRatio: (AVRational)(ctx.sample_aspect_ratio),
-		SampleRate:        int(ctx.sample_rate),
-		FrameSize:         int(ctx.frame_size),
-	})
+	par := jsonAVCodecParameters{
+		CodecType: AVMediaType(ctx.codec_type),
+		CodecID:   AVCodecID(ctx.codec_id),
+		CodecTag:  uint32(ctx.codec_tag),
+		BitRate:   int64(ctx.bit_rate),
+	}
+	switch ctx.CodecType() {
+	case AVMEDIA_TYPE_AUDIO:
+		par.jsonAVCodecParametersAudio = &jsonAVCodecParametersAudio{
+			SampleFormat:  AVSampleFormat(ctx.format),
+			SampleRate:    int(ctx.sample_rate),
+			ChannelLayout: AVChannelLayout(ctx.ch_layout),
+			FrameSize:     int(ctx.frame_size),
+		}
+	case AVMEDIA_TYPE_VIDEO:
+		par.jsonAVCodecParameterVideo = &jsonAVCodecParameterVideo{
+			PixelFormat:       AVPixelFormat(ctx.format),
+			Width:             int(ctx.width),
+			Height:            int(ctx.height),
+			SampleAspectRatio: AVRational(ctx.sample_aspect_ratio),
+		}
+	}
+
+	return json.Marshal(par)
 }
 
 func (ctx *AVCodecParameters) String() string {
-	if str, err := json.MarshalIndent(ctx, "", "  "); err != nil {
-		return err.Error()
-	} else {
-		return string(str)
-	}
+	data, _ := json.MarshalIndent(ctx, "", "  ")
+	return string(data)
 }
 
 ////////////////////////////////////////////////////////////////////////////////

sys/ffmpeg61/avformat.go

@@ -112,11 +112,12 @@ type jsonAVFormatContext struct {
 	Input      *AVInputFormat  `json:"input_format,omitempty"`
 	Output     *AVOutputFormat `json:"output_format,omitempty"`
 	Url        string          `json:"url,omitempty"`
-	NumStreams uint            `json:"num_streams,omitempty"`
+	NumStreams uint            `json:"nb_streams,omitempty"`
 	Streams    []*AVStream     `json:"streams,omitempty"`
 	StartTime  int64           `json:"start_time,omitempty"`
 	Duration   int64           `json:"duration,omitempty"`
 	BitRate    int64           `json:"bit_rate,omitempty"`
+	PacketSize uint            `json:"packet_size,omitempty"`
 	Flags      AVFormatFlag    `json:"flags,omitempty"`
 }
 
@@ -131,6 +132,7 @@ func (ctx *AVFormatContext) MarshalJSON() ([]byte, error) {
 		StartTime:  int64(ctx.start_time),
 		Duration:   int64(ctx.duration),
 		BitRate:    int64(ctx.bit_rate),
+		PacketSize: uint(ctx.packet_size),
 		Flags:      AVFormatFlag(ctx.flags),
 	})
 }
@@ -263,6 +265,83 @@ func (ctx *AVFormatContext) Duration() int64 {
 ////////////////////////////////////////////////////////////////////////////////
 // AVFormatFlag
 
+const (
+	AVFMT_FLAG_NONE            AVFormatFlag = 0
+	AVFMT_FLAG_GENPTS          AVFormatFlag = C.AVFMT_FLAG_GENPTS          ///< Generate missing pts even if it requires parsing future frames.
+	AVFMT_FLAG_IGNIDX          AVFormatFlag = C.AVFMT_FLAG_IGNIDX          ///< Ignore index.
+	AVFMT_FLAG_NONBLOCK        AVFormatFlag = C.AVFMT_FLAG_NONBLOCK        ///< Do not block when reading packets from input.
+	AVFMT_FLAG_IGNDTS          AVFormatFlag = C.AVFMT_FLAG_IGNDTS          ///< Ignore DTS on frames that contain both DTS & PTS
+	AVFMT_FLAG_NOFILLIN        AVFormatFlag = C.AVFMT_FLAG_NOFILLIN        ///< Do not infer any values from other values, just return what is stored in the container
+	AVFMT_FLAG_NOPARSE         AVFormatFlag = C.AVFMT_FLAG_NOPARSE         ///< Do not use AVParsers, you also must set AVFMT_FLAG_NOFILLIN as the fillin code works on frames and no parsing -> no frames. Also seeking to frames can not work if parsing to find frame boundaries has been disabled
+	AVFMT_FLAG_NOBUFFER        AVFormatFlag = C.AVFMT_FLAG_NOBUFFER        ///< Do not buffer frames when possible
+	AVFMT_FLAG_CUSTOM_IO       AVFormatFlag = C.AVFMT_FLAG_CUSTOM_IO       ///< The caller has supplied a custom AVIOContext, don't avio_close() it.
+	AVFMT_FLAG_DISCARD_CORRUPT AVFormatFlag = C.AVFMT_FLAG_DISCARD_CORRUPT ///< Discard frames marked corrupted
+	AVFMT_FLAG_FLUSH_PACKETS   AVFormatFlag = C.AVFMT_FLAG_FLUSH_PACKETS   ///< Flush the AVIOContext every packet.
+	AVFMT_FLAG_BITEXACT        AVFormatFlag = C.AVFMT_FLAG_BITEXACT        // When muxing, try to avoid writing any random/volatile data to the output.
+	AVFMT_FLAG_SORT_DTS        AVFormatFlag = C.AVFMT_FLAG_SORT_DTS        ///< try to interleave outputted packets by dts (using this flag can slow demuxing down)
+	AVFMT_FLAG_FAST_SEEK       AVFormatFlag = C.AVFMT_FLAG_FAST_SEEK       ///< Enable fast, but inaccurate seeks for some formats
+	AVFMT_FLAG_SHORTEST        AVFormatFlag = C.AVFMT_FLAG_SHORTEST        ///< Stop muxing when the shortest stream stops.
+	AVFMT_FLAG_AUTO_BSF        AVFormatFlag = C.AVFMT_FLAG_AUTO_BSF        ///< Add bitstream filters as requested by the muxer
+	AVFMT_FLAG_MIN                          = AVFMT_FLAG_GENPTS
+	AVFMT_FLAG_MAX                          = AVFMT_FLAG_AUTO_BSF
+)
+
+func (f AVFormatFlag) FlagString() string {
+	switch f {
+	case AVFMT_FLAG_NONE:
+		return "AVFMT_FLAG_NONE"
+	case AVFMT_FLAG_GENPTS:
+		return "AVFMT_FLAG_GENPTS"
+	case AVFMT_FLAG_IGNIDX:
+		return "AVFMT_FLAG_IGNIDX"
+	case AVFMT_FLAG_NONBLOCK:
+		return "AVFMT_FLAG_NONBLOCK"
+	case AVFMT_FLAG_IGNDTS:
+		return "AVFMT_FLAG_IGNDTS"
+	case AVFMT_FLAG_NOFILLIN:
+		return "AVFMT_FLAG_NOFILLIN"
+	case AVFMT_FLAG_NOPARSE:
+		return "AVFMT_FLAG_NOPARSE"
+	case AVFMT_FLAG_NOBUFFER:
+		return "AVFMT_FLAG_NOBUFFER"
+	case AVFMT_FLAG_CUSTOM_IO:
+		return "AVFMT_FLAG_CUSTOM_IO"
+	case AVFMT_FLAG_DISCARD_CORRUPT:
+		return "AVFMT_FLAG_DISCARD_CORRUPT"
+	case AVFMT_FLAG_FLUSH_PACKETS:
+		return "AVFMT_FLAG_FLUSH_PACKETS"
+	case AVFMT_FLAG_BITEXACT:
+		return "AVFMT_FLAG_BITEXACT"
+	case AVFMT_FLAG_SORT_DTS:
+		return "AVFMT_FLAG_SORT_DTS"
+	case AVFMT_FLAG_FAST_SEEK:
+		return "AVFMT_FLAG_FAST_SEEK"
+	case AVFMT_FLAG_SHORTEST:
+		return "AVFMT_FLAG_SHORTEST"
+	case AVFMT_FLAG_AUTO_BSF:
+		return "AVFMT_FLAG_AUTO_BSF"
+	default:
+		return fmt.Sprintf("AVFormatFlag(0x%06X)", int(f))
+	}
+}
+
+func (f AVFormatFlag) MarshalJSON() ([]byte, error) {
+	return json.Marshal(f.String())
+}
+
+func (f AVFormatFlag) String() string {
+	if f == AVFMT_FLAG_NONE {
+		return f.FlagString()
+	}
+	str := ""
+	for i := AVFMT_FLAG_MIN; i <= AVFMT_FLAG_MAX; i <<= 1 {
+		if f&i != 0 {
+			str += "|" + i.FlagString()
+		}
+	}
+	return str[1:]
+}
+
 func (f AVFormatFlag) Is(flag AVFormatFlag) bool {
 	return f&flag == flag
 }

writer_test.go

@@ -23,7 +23,7 @@ func Test_writer_001(t *testing.T) {
 
 	// Write audio file
 	filename := filepath.Join(t.TempDir(), t.Name()+".mp3")
-	stream, err := manager.AudioParameters("mono", "s16", 22050)
+	stream, err := manager.AudioParameters("mono", "fltp", 22050)
 	if !assert.NoError(err) {
 		t.SkipNow()
 	}