【音视频编程】在浏览器中播放pcm音频的案例

Tue, 01 Jan 2019 12:30:00 +0000

前言
如何播放
- 如何让浏览器识别 pcm
- javascript 如何处理文件流
Reference

前言

最近在整理音视频编程的知识，回忆起半年多，有一次需求是在后台播放某来源的 pcm 文件，当时处理方法用了点技巧，记录下来

背景：业务需求，在web后台里播放 pcm 文件，文件不大(约300KB)

如何播放

浏览器是无法直接播放 pcm 音频的，因为 pcm 是比较原始的音频格式:

PCM（Puls Code Modulation）全称脉码调制录音，PCM录音就是将声音的模拟信号表示成0,1标识的数字信号，未经任何编码和压缩处理，所以可以认为PCM是未经压缩的音频原始格式。PCM格式文件中不包含头部信息，播放器无法知道采样率，声道数，采样位数，音频数据大小等信息，导致无法播放。

如何让浏览器识别 pcm

浏览器可以播放另一种音频格式：WAV格式全称为WAVE，前面提到只需要在PCM文件的前面添加WAV文件头，就可以生成WAV格式文件

所以我的解决方法是给 pcm 添加 wav header，接下来就是 browser javascript 的实践编码了

javascript 如何处理文件流

js 在处理文件流、网络数据，常用到 ArrayBuffer 类型，关于 ArrayBuffer 类型的API调用方法，需要事先多了解。

第一步，ajax异步获取网络 pcm 文件的 ArrayBuffer

const getWebFileArrayBuffer = async (url) => {
  return await fetch(url).then(response => response.arrayBuffer())
}

第二步，对获取的 pcm 文件流 ArrayBuffer 添加 wav header，下面以代码注释为大家解释

const getWebPcm2WavArrayBuffer = async (url) => {
  const bytes = await getWebFileArrayBuffer(url)
  return addWavHeader(bytes, 16000, 16, 1)
}

const addWavHeader = function (samples, sampleRateTmp, sampleBits, channelCount) {
  let dataLength = samples.byteLength
  let buffer = new ArrayBuffer(44 + dataLength)
  let view = new DataView(buffer)
  function writeString (view, offset, string) {
    for (let i = 0; i < string.length; i++) {
      view.setUint8(offset + i, string.charCodeAt(i))
    }
  }

  let offset = 0
  /* 资源交换文件标识符 */
  writeString(view, offset, 'RIFF'); offset += 4
  /* 下个地址开始到文件尾总字节数,即文件大小-8 */
  view.setUint32(offset, /* 32 */ 36 + dataLength, true); offset += 4
  /* WAV文件标志 */
  writeString(view, offset, 'WAVE'); offset += 4
  /* 波形格式标志 */
  writeString(view, offset, 'fmt '); offset += 4
  /* 过滤字节,一般为 0x10 = 16 */
  view.setUint32(offset, 16, true); offset += 4
  /* 格式类别 (PCM形式采样数据) */
  view.setUint16(offset, 1, true); offset += 2
  /* 通道数 */
  view.setUint16(offset, channelCount, true); offset += 2
  /* 采样率,每秒样本数,表示每个通道的播放速度 */
  view.setUint32(offset, sampleRateTmp, true); offset += 4
  /* 波形数据传输率 (每秒平均字节数) 通道数×每秒数据位数×每样本数据位/8 */
  view.setUint32(offset, sampleRateTmp * channelCount * (sampleBits / 8), true); offset += 4
  /* 快数据调整数 采样一次占用字节数 通道数×每样本的数据位数/8 */
  view.setUint16(offset, channelCount * (sampleBits / 8), true); offset += 2
  /* 每样本数据位数 */
  view.setUint16(offset, sampleBits, true); offset += 2
  /* 数据标识符 */
  writeString(view, offset, 'data'); offset += 4
  /* 采样数据总数,即数据总大小-44 */
  view.setUint32(offset, dataLength, true); offset += 4
  function floatTo32BitPCM (output, offset, input) {
    input = new Int32Array(input)
    for (let i = 0; i < input.length; i++, offset += 4) {
      output.setInt32(offset, input[i], true)
    }
  }
  function floatTo16BitPCM (output, offset, input) {
    input = new Int16Array(input)
    for (let i = 0; i < input.length; i++, offset += 2) {
      output.setInt16(offset, input[i], true)
    }
  }
  function floatTo8BitPCM (output, offset, input) {
    input = new Int8Array(input)
    for (let i = 0; i < input.length; i++, offset++) {
      output.setInt8(offset, input[i], true)
    }
  }
  if (sampleBits == 16) {
    floatTo16BitPCM(view, 44, samples)
  } else if (sampleBits == 8) {
    floatTo8BitPCM(view, 44, samples)
  } else {
    floatTo32BitPCM(view, 44, samples)
  }
  return view.buffer
}

第三步，在浏览器播放 pcm 转出的 wav 的文件流 ArrayBuffer
先转成 base64 格式

const getWebPcm2WavBase64 = async (url) => {
  let bytes = await getWebPcm2WavArrayBuffer(url)
  return `data:audio/wav;base64,${btoa(new Uint8Array(bytes).reduce((data, byte) => {
    return data + String.fromCharCode(byte)
  }, ''))}`
}

将 base64 字符串放入<audio>组件中，这里以 react/ant design 的组件为例，封装一个方法

const playWebPcm = async (url) => {
    try {
    let pcmBase64 = await fileServer.getWebPcm2WavBase64(url)
    Modal.info({
        title: '播放音频',
        content: (
        <audio controls src={pcmBase64} type="audio/wav" autoPlay />
        ),
        onOk () {},
        okText: '关闭',
    })
    } catch (err) {
    console.error(err)
    message.error('预载音频文件失败')
    }
}

Reference

音频格式简介和PCM转换成WAV，Java版本

【音视频编程】将ffmpeg封装golang/cgo库

Mon, 24 Dec 2018 12:30:00 +0000

前言
认识cgo的封装技巧
开始编程
测试代码
动态链接或者静态链接
- 打包动态链接库
- 静态链接编译
Reference

前言

继上一篇 ffmpeg音视频C编程入门, 使用高性能的C语言进行音视频的处理，比较执行效率比较高，但是业务需求，快捷开发需要使用更方便的语言，比如 golang，本文介绍如何将将视频转成GIF 的C语言方法封装成 golang 方法以便调用。

认识cgo的封装技巧

最简单的 cgo 封装例子看这篇 cgo快速入门

我这里讲几个注意事项

CGO构建程序会自动构建当前目录下的C源文件，即是 go 会将当前目录下 *.c 文件都编译成 *.o目标文件，再链接汇编，这个特点衍生出几个注意事项:
- go 代码以静态库或动态库方式引用 C 函数的话，需要将对应的C源文件移出 go源文件所在的目录
- 如果想要将 C 函数编译到 go 程序，就需要将 C源文件与 go 文件放在同一目录下
在C/C++混编下， go 中引用 C 函数，需要将 C 函数名置于全局，即 extern C

开始编程

第一步，处理例子中已经写好的 gen_gif 方法，修改 gen_gif.h 文件

#ifdef __cplusplus
extern "C" {
#endif

int gen_gif(const int gifSeconds, const int rotate, void* data, int data_size, void* outBuf, int outBufLen, int *outSize);

#ifdef __cplusplus
}
#endif

在处理 ffmpeg 的 av_log 日志的回调方法

/* log.c */
/* 
mpeg 的日志库用法

#include <libavutil/log.h>
// 设置日志级别
av_log_set_level(AV_LOG_DEBUG)
// 打印日志
av_log(NULL, AV_LOG_INFO,"...%s\n",op)

*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <libavutil/log.h>

// 定义输出日志的函数，留白给使用者实现
extern void Ffmpeglog(int , char*);

static void log_callback(void *avcl, int level, const char *fmt, va_list vl) 
{
    (void) avcl;
    char log[1024] = {0};
    //　int vsnprintf(buffer,bufsize ,fmt, argptr) , va_list 是可变参数的指针，相关方法有: va_start(), type va_atg(va_list, type), va_end()
    int n = vsnprintf(log, 1024, fmt, vl);
    if (n > 0 && log[n - 1] == '\n')
        log[n - 1] = 0;
    if (strlen(log) == 0)
        return;
    Ffmpeglog(level, log);
}

void set_log_callback()
{
    // 给 av 解码器注册日志回调函数
    av_log_set_callback(log_callback);
}

第二步，编写 go 文件

package c

/*
#include <stdlib.h>
#include "gen_gif.h"
#include "log.h"
#cgo LDFLAGS: -lavcodec -lavformat -lswscale -lavutil -lavfilter -lm
*/
import "C"

import (
	"errors"
	"fmt"
	"unsafe"
)

func init() {
	C.set_log_callback()
}

var logger func(s string) = nil

func SetFfmpegLogger(f func(s string)) {
	logger = f
}

//export Ffmpeglog
func Ffmpeglog(l C.int, t *C.char) {
	if l <= 32 {
		if logger == nil {
			fmt.Printf("ffmpeg log:%s\n", C.GoString(t))
		} else {
			logger(fmt.Sprintf("ffmpeg log:%s\n", C.GoString(t)))
		}
	}
}

func GenGif(second, rotate int, input []byte) (err error, output []byte) {
	buf := make([]byte, 1<<20)
	var outsz C.int
	ret := C.gen_gif(C.int(second), C.int(rotate), unsafe.Pointer(&input[0]), C.int(len(input)), unsafe.Pointer(&buf[0]), C.int(len(buf)), &outsz)
	if ret != 0 {
		return errors.New(fmt.Sprintf("error, ret=%v", ret)), nil
	}
	output = make([]byte, outsz)
	copy(output, buf[:outsz])
	return nil, output
}

使用动态链接的方式，调用 ffmpeg 的 libav* 的函数库，设置 #cgo LDFLAGS 的动态链接选项
实现 log.c 中提供使用者实现的函数，使用 go 语言的方法打印日志
处理调用 C 函数传参的指针、变量，通过 import "C" 提供的方法转化变量

测试代码

将上文编写好的代码，提交到代码仓库，或者在本地的 GOPATH 中建好相应的目录，如笔者的 github.com/lightfish-zhang/mpegUtil/c 路径。

接下来，可以在业务需要的地方使用 GenGif() 了，让我们来测试一下

package main

import (
	"fmt"
	"io/ioutil"
	"os"

	mpegUtil "github.com/lightfish-zhang/mpegUtil/c"
)

func main() {
	if len(os.Args) < 3 {
		fmt.Printf("Usage: %s <input file> <output file>\n", os.Args[0])
		os.Exit(1)
	}
	inFile, err := os.Open(os.Args[1])
	if err != nil {
		fmt.Printf("open file fail, path=%v, err=%v", os.Args[1], err)
		os.Exit(1)
	}
	outFile, err := os.Create(os.Args[2])
	if err != nil {
		fmt.Printf("create file fail, path=%v, err=%v", os.Args[2], err)
		os.Exit(1)
	}
	input, err := ioutil.ReadAll(inFile)
	if err != nil {
		fmt.Printf("read file fail, err=%v", err)
		os.Exit(1)
	}

	err, output := mpegUtil.GenGif(5, 90, input)
	if err != nil {
		fmt.Printf("generate gif fail, err=%v", err)
		os.Exit(1)
	}
	_, err = outFile.Write(output)
	if err != nil {
		fmt.Printf("write file fail, err=%v", err)
		os.Exit(1)
	}
}

我在本地执行，对某一个 mp4 文件进行转码 GIF，如

./genGif test.mp4 test.gif

运行成功，在我的电脑上可以看到完美的 GIF 图片！

动态链接或者静态链接

golang 语言的优势是打包出一个静态的执行文件，可以在相同平台下运行。但是，我们例子是动态链接了 ffmpeg 的 libav*.so，在编译或者部署时，都需要在机器上安装好 ffmpeg 库。

有没有便利的方法进行编译或部署呢？

打包动态链接库

一个使用 LD_LIBRARY_PATH 指定动态链接目录的小技巧，不过这个技巧需要编译机器与部署机器的运行环境差不多，除了 libav*.so 可以没有预先安装在部署机器。为了保持 libc.so 的函数可用，最好机器之间的 linux 版本一样。

使用 ldd genGif 查看编译出来的执行文件，需要动态链接哪些 *.so 文件，将关键的文件拷贝出来，比如 libav* 的 so 文件是必须的，其他比如 libm.so, libz.so 视部署机器有没有而定。

部署时候，需要把以上找到的 *.so 一起拷贝到目标机器上，同时在运行 golang 程序时，设置好全局变量 LD_LIBRARY_PATH，指向 *.so 文件目录。

静态链接编译

这个方法也需要机器的 linux 最好保持一致，ffmpeg 依赖的 libc.so 的函数好像会随着 linux 版本不同而有所差异。

准备好各种依赖库的静态库，参照如下命令

编译C例子

g++ -o gen_gif -I./ -I./ffmpeg/include -I/usr/local/include main.o gen_gif.a ./ffmpeg/lib/libavdevice.a ./ffmpeg/lib/libavfilter.a ./ffmpeg/lib/libavformat.a ./ffmpeg/lib/libavcodec.a  ./ffmpeg/lib/libavutil.a  ./ffmpeg/lib/libswreample.a  ./ffmpeg/lib/libswcale.a  ./lib/liblzma.a ./lib/libm.a ./lib/libz.a ./lib/libbz2.a -lpthread

编译 golang 例子，修改 #cgo 命令

/*
#cgo CFLAGS: -I./ffmpeg/include -I/usr/local/include
#cgo LDFLAGS: -L./lib -L./ffmpeg/lib
*/

Reference

cgo快速入门

【音视频编程】ffmpeg的C语言编程

Thu, 20 Dec 2018 12:30:00 +0000

前言
解码过程总览
Reference

前言

本文以 ffmpeg 工具，讲述如何认识音视频编程，你可以了解到常见视频格式的大概样子，一步步学会如何使用 ffmpeg 的 C 语言 API

本文重于动手实践，代码仓库：mpegUtil

笔者的开发环境：Arch Linux 4.19.12, ffmpeg version n4.1

解码过程总览

以下是解码流程图，逆向即是编码流程

本文是音视频编程入门篇，先略过传输协议层，主要讲格式层与编解码层的编程例子。

写在最前面的日志处理

边编程边执行，查看日志输出，是最直接的反馈，以感受学习的进度。对于 ffmpeg 的日志，需要提前这样处理：

/* log.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <libavutil/log.h>

// 定义输出日志的函数，留白给使用者实现
extern void Ffmpeglog(int , char*);

static void log_callback(void *avcl, int level, const char *fmt, va_list vl) 
{
    (void) avcl;
    char log[1024] = {0};
    int n = vsnprintf(log, 1024, fmt, vl);
    if (n > 0 && log[n - 1] == '\n')
        log[n - 1] = 0;
    if (strlen(log) == 0)
        return;
    Ffmpeglog(level, log);
}

void set_log_callback()
{
    // 给 av 解码器注册日志回调函数
    av_log_set_callback(log_callback);
}

/* main.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void Ffmpeglog(int l, char* t) {
    if(l <= AV_LOG_INFO)
        fprintf(stdout, "%s\n", t);
}

ffmpeg 有不同等级的日志，本文只需使用 AV_LOG_INFO 即可。

第一步，查看音视频格式信息

料理食材的第一步，得先懂得食材的来源和特性。

来源，互联网在线观看（http/rtmp）、播放设备上存储的视频文件（file）。
格式，如何查看视频文件的格式呢，以下有 unix 命令行示例，至于 windows 系统，查看文件属性即可。

# linux 上查看视频文件信息
ffmpeg -i example.mp4

以某个mp4文件为例，输出：

Input #0, mov,mp4,m4a,3gp,3g2,mj2, from 'example.mp4':
  Metadata:
    major_brand     : isom
    minor_version   : 512
    compatible_brands: isomiso2avc1mp41
    encoder         : Wxmm_900012345
  Duration: 00:00:58.21, start: 0.000000, bitrate: 541 kb/s
    Stream #0:0(und): Video: h264 (High) (avc1 / 0x31637661), yuv420p, 368x640, 487 kb/s, 24 fps, 24 tbr, 12288 tbn, 48 tbc (default)
    Metadata:
      handler_name    : VideoHandler
    Stream #0:1(und): Audio: aac (LC) (mp4a / 0x6134706D), 44100 Hz, stereo, fltp, 48 kb/s (default)
    Metadata:
      handler_name    : SoundHandler

根据命令输出信息，视频文件中有两个 stream, 即 video 与 audio，视频流与音频流。

stream 0, 是视频数据，编码格式为h264，24 fps 意为 24 frame per second，即每秒24帧，比特率487 kb/s,
stream 1, 是音频数据，编码格式为acc，采样率44100 Hz，比特率48 kb/s

【编程实操】读取音视频流的格式信息

在互联网场景中，在线观看视频才是常见需求，那么，计算机如何读取视频流的信息呢，下面以 ffmpeg 代码讲述

    /* C代码例子，省略了处理错误的逻辑 */

    AVFormatContext *fmt_ctx = NULL; // AV 格式上下文
    AVIOContext *avio_ctx = NULL; // AV IO 上下文
    unsigned char *avio_ctx_buffer = NULL; // input buffer

    fmt_ctx = avformat_alloc_context();// 获得 AV format 句柄
    avio_ctx_buffer = (unsigned char *)av_malloc(data_size); // ffmpeg分配内存的方法，给输入分配缓存

    /* fread(file) or memcpy(avio_ctx_buffer, inBuf, n)  省略拷贝文件流的步骤 */

    // 给 av format context 分配 io 操作的句柄，必要传参：输入数据的指针、数据大小、write_flag＝０表明buffer不可写，其他参数忽略，置 NULL
    avio_ctx = avio_alloc_context(avio_ctx_buffer, data_size, 0, NULL, NULL, NULL, NULL);
    fmt_ctx->pb = avio_ctx;

    // 打开输入的数据流，读取 header 的格式内容，注意必须的后续处理 avformat_close_input()
    avformat_open_input(&fmt_ctx, NULL, NULL, NULL)

    // 获取音视频流的信息
    avformat_find_stream_info(fmt_ctx, NULL) 

ffmpeg 有一个方法直接打印音视频信息

av_dump_format(fmt_ctx, 0, NULL, 0);

print: (源码的输出格式凌乱，笔者整理过)

Input #0, mov,mp4,m4a,3gp,3g2,mj2, from '(null)':
Stream #0:0 : Video: h264 (High) (avc1 / 0x31637661), yuv420p, 368x640, 487 kb/s 24 fps,
Stream #0:1 : Audio: aac (LC) (mp4a / 0x6134706D), 44100 Hz, stereo, fltp, 48 kb/s

实践编程，获取音视频信息，当然需要细致地调用API，看下面代码

查看音视频流的索引、类型、解码器类型

  avformat_find_stream_info(fmt_ctx, NULL);

  for(int i=0; i<fmt_ctx->nb_streams; i++){
      AVStream *stream = fmt_ctx->streams[i];
      AVCodecParameters *codec_par = stream->codecpar;
      av_log(NULL, AV_LOG_INFO, "find audio stream index=%d, type=%s, codec id=%d", 
        i, av_get_media_type_string(codec_par->codec_type), codec_par->codec_id);
  }

print:

find audio stream index=0, type=video, codec id=27
find audio stream index=1, type=audio, codec id=86018

看到没，上面代码只获得解码器的id值(枚举类型)，那么解码器的信息呢，加上下面代码，可以看到音视频流的格式，同时获得解码器，方便“解码步骤”使用。

  AVCodec *decodec = NULL;
  decodec = avcodec_find_decoder(codec_par->codec_id); // 获得解码器
  av_log(NULL, AV_LOG_INFO, "find codec name=%s\t%s", decodec->name, decodec->long_name);

print:

find audio stream index=0, type=video, codec id=27
find codec name=h264    H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10
find audio stream index=1, type=audio, codec id=86018
find codec name=aac     AAC (Advanced Audio Coding)

关于视频，可以查看帧率(一秒有多少帧画面)

  // 获得一个分数
  AVRational framerate = av_guess_frame_rate(fmt_ctx, stream, NULL);
  av_log(NULL, AV_LOG_INFO, "video framerate=%d/%d", framerate.num, framerate.den);

print:

video framerate=24/1

至此，我们掌握了如何利用 ffmpeg 的 C 语言 API 来读取音视频文件流的信息

第二步，解码

简单说一下音视频文件的解码过程，对大部分音视频格式来说，在原始流的数据中，不同类型的流会按时序先后交错在一起，这是多路复用，这样的数据分布，即有利于播放器打开本地文件，读取某一时段的音视频时，方便进行fseek操作（移动文件描述符的读写指针）；也有利于网络在线观看视频，“空投”从某一刻开始播放视频，从文件某一段下载数据。

直观的看下面的循环读取文件流的代码

    /* begin 解码过程 */
    AVPacket *pkt;
    AVFrame *frame;

    // 分配原始文件流packet的缓存
    pkt = av_packet_alloc();
    // 分配 AV 帧 的内存
    frame = av_frame_alloc();

    // 在循环中不断读取下一个文件流的 packet 包
    while (av_read_frame(fmt_ctx, pkt) >= 0) {
      if(pkt->size){
            /*
            demux 解复用
            原始流的数据中，不同格式的流会交错在一起（多路复用）
            从原始流中读取的每一个 packet 的流可能是不一样的，需要判断 packet 的流索引，按类型处理
            */
            if(pkt->stream_index == video_stream_idx){
              //　此处省略处理视频的逻辑
            }else if(pkt->stream_index == audio_stream_idx){
              //　此处省略处理音频的逻辑
            }
        }
        av_packet_unref(pkt);
        av_frame_unref(frame);
    }
    /* end 解码过程 */

    // flush data
    avcodec_send_packet(video_decodec_ctx, NULL);
    avcodec_send_packet(audio_decodec_ctx, NULL);

上面代码是对音视频流进行解复用的主要过程，在循环中分别处理不同类型的流数据，到了这一步，就是使用解码器对循环中获取的 packet 包进行解码。

解码前的准备

ffmepg 中，解码工具需要初始化好两个指针，一个是解码器，一个是解码器上下文，上下文是用来存储此次操作的变量集合，比如 io 的句柄、解码的帧数累加值，视频的帧率等等。让我们重新编写上面读取音视频流的循环，给音视频流分别分配好这两个指针，并且处理好错误返回值。（下面代码的 goto 语句暂且略过，后面再提）

   // find codec
    int video_stream_idx = -1, audio_stream_idx = -1;
    AVStream *video_stream = NULL, *audio_stream = NULL;
    AVCodecContext *video_decodec_ctx=NULL, *audio_decodec_ctx=NULL;

    // AVFormatContext.nb_stream 记录了该 URL 中包含有几路流
    for(int i=0; i<fmt_ctx->nb_streams; i++){
        AVStream *stream = fmt_ctx->streams[i];
        AVCodecParameters *codec_par = stream->codecpar;
        AVCodec *decodec = NULL;
        AVCodecContext *decodec_ctx = NULL;

        av_log(NULL, AV_LOG_INFO, "find audio stream index=%d, type=%s, codec id=%d", 
                i, av_get_media_type_string(codec_par->codec_type), codec_par->codec_id);

        // 获得解码器
        decodec = avcodec_find_decoder(codec_par->codec_id);
        if(!decodec){
            av_log(NULL, AV_LOG_ERROR, "fail to find decodec\n");
            goto clean2;
        }

        av_log(NULL, AV_LOG_INFO, "find codec name=%s\t%s", decodec->name, decodec->long_name);

        // 分配解码器上下文句柄
        decodec_ctx = avcodec_alloc_context3(decodec);
        if(!decodec_ctx){
            av_log(NULL, AV_LOG_ERROR, "fail to allocate codec context\n");
            goto clean2;
        }

        // 复制流信息到解码器上下文
        if(avcodec_parameters_to_context(decodec_ctx, codec_par) < 0){
            av_log(NULL, AV_LOG_ERROR, "fail to copy codec parameters to decoder context\n");
            avcodec_free_context(&decodec_ctx);
            goto clean2;
        }

        // 初始化解码器
        if ((ret = avcodec_open2(decodec_ctx, decodec, NULL)) < 0) {
            av_log(NULL, AV_LOG_ERROR, "Failed to open %s codec\n", decodec->name);
            return ret;
        }

        if( stream->codecpar->codec_type == AVMEDIA_TYPE_VIDEO){
            // 视频的属性，帧率，这里 av_guess_frame_rate() 非必须，看业务是否需要使用帧率参数
            decodec_ctx->framerate = av_guess_frame_rate(fmt_ctx, stream, NULL);
            av_log(NULL, AV_LOG_INFO, "video framerate=%d/%d", decodec_ctx->framerate.num, decodec_ctx->framerate.den);
            video_stream_idx = i;
            video_stream = stream;
            video_decodec_ctx = decodec_ctx;
        } else if( stream->codecpar->codec_type == AVMEDIA_TYPE_AUDIO){
            audio_stream_idx = i;
            audio_stream = stream;
            audio_decodec_ctx = decodec_ctx;
        } 
    }

以上方式是循环读取文件的所有stream，便于查看文件中有什么流，如视频、音频、字幕等，若是业务需求，只要对单独一个流（比如视频），可以用以下方式获取特定的流。

    if (avformat_find_stream_info(fmt_ctx, NULL) < 0) {
        av_log(NULL, AV_LOG_ERROR, "Could not find stream information\n");
        goto clean1;
    }
    ret = av_find_best_stream(fmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
    if (ret < 0) {
        av_log(NULL, AV_LOG_ERROR, "Could not find %s stream\n",
                av_get_media_type_string(type));
        return ret;
    }
    int stream_index = ret;
    AVStream *st = fmt_ctx->streams[stream_index];

解码的循环

修改上面解码的循环，以视频流为例，如何从流中读取帧，为便于理解，在关键地方有清楚的注释。

    while (av_read_frame(fmt_ctx, pkt) >= 0) {
        if(pkt->size){
            /*
            demux 解复用
            原始流的数据中，不同格式的流会交错在一起（多路复用）
            从原始流中读取的每一个 packet 的流可能是不一样的，需要判断 packet 的流索引，按类型处理
            */
            if(pkt->stream_index == video_stream_idx){
                // 向解码器发送原始压缩数据 packet
                if((ret = avcodec_send_packet(video_decodec_ctx, pkt)) < 0){
                    av_log(NULL, AV_LOG_ERROR, "Error sending a packet for decoding, ret=%d", ret);
                    break;
                }
                /*
                解码输出视频帧
                avcodec_receive_frame()返回 EAGAIN 表示需要更多帧来参与编码
                像 MPEG等格式, P帧(预测帧)需要依赖I帧(关键帧)或者前面的P帧，使用比较或者差分方式编码
                读取frame需要循环，因为读取多个packet后，可能获得多个frame
                */ 
                while(ret >= 0){
                    ret = avcodec_receive_frame(video_decodec_ctx, frame);
                    if(ret == AVERROR(EAGAIN) || ret == AVERROR_EOF){
                        break;
                    }

                    /* 
                    DEBUG 打印出视频的时间
                    pts = display timestamp
                    视频流有基准时间 time_base ，即每 1 pts 的时间间隔(单位秒)
                    使用 pts * av_q2d(time_base) 可知当前帧的显示时间
                    */
                    if(video_decodec_ctx->frame_number%100 == 0){
                        av_log(NULL, AV_LOG_INFO, "read video No.%d frame, pts=%d, timestamp=%f seconds", 
                            video_decodec_ctx->frame_number, frame->pts, frame->pts * av_q2d(video_stream->time_base));
                    }

                    /*
                    在第一个视频帧读取成功时，可以进行：
                    １、若要转码，初始化相应的编码器
                    ２、若要加过滤器，比如水印、旋转等，这里初始化 filter
                    */
                    if (video_decodec_ctx->frame_number == 1) {

                    }else{

                    }
                    av_frame_unref(frame);
                }
            }else if(pkt->stream_index == audio_stream_idx){

            }
        }

        av_packet_unref(pkt);
        av_frame_unref(frame);　
    }

回收内存

上文的代码中，多次出现 goto 语句，我认为适当的使用 goto 使编程更加方便，比如执行过程结束的清理工作，以下是回收 ffmpeg AV 库产生的各种变量的内存，C/C++语言编程都需要多注意这一点。

clean5:
    av_frame_free(&frame);
    //av_parser_close(parser);
clean4:
    av_packet_free(&pkt);
clean3:
    if(NULL != video_decodec_ctx)
        avcodec_free_context(&video_decodec_ctx);
    if(NULL != audio_decodec_ctx)
        avcodec_free_context(&audio_decodec_ctx);
clean2:
    av_freep(&fmt_ctx->pb->buffer);
    av_freep(&fmt_ctx->pb);
clean1:
    avformat_close_input(&fmt_ctx);
end:
    return ret;

自由发挥

看到了这里，可以说入门 ffmpeg 编程了，什么，你问后面的转码怎么做？笔者就留白了，本文已经介绍了最基本的解码过程了，编码也就是逆向过程，我建议阅读 ffmepg 官方源码的example，以及多了解音视频各种格式的知识。

实际例子

我提供两个小例子在 github 上

请安装好 linux 下 ffmepg 环境，找到例子代码里的Ｍakefile 文件编译，例如：

make -f Makefile_test_dump_info

以后我会将这两个小例子修改，实现跨语言调用，如 nodejs addon 或 golang cgo

Reference

ffmpeg example (本文代码就是从example改过来的)

【学习记录】机器学习MNIST例子-卷积网络

Fri, 30 Nov 2018 12:30:00 +0000

前言

最近公司的深度学习小组来给我们民工扫盲了，抱大腿学python写机器学习的案例

jupyter 笔记

【学习记录】机器学习MNIST例子-全连接softmax

Tue, 20 Nov 2018 12:30:00 +0000

前言

最近公司的深度学习小组来给我们民工扫盲了，抱大腿学python写机器学习的案例

jupyter 笔记

【学习记录】深度学习基本概念

Wed, 05 Sep 2018 12:30:00 +0000

前言
一个简单的例子理解机器学习的过程
学习算法的几个基本概念
思考题

前言

这是一份我的学习记录，本文知识点来源于【实验楼】网站的课程使用 Python 实现深度神经网络，在此整理笔记。

一个简单的例子理解机器学习的过程

计算圆的面积

# 代码片段 2
def learn(model,data):

    ... # 通过数据data训练模型model的代码

    return model # 已经训练好参数的模型

def test(model,x):

    ... # 将x输入模型model中得出结果y的代码

    return y # 返回计算结果--圆的面积

trained_model=learn(init_model,data) # 通过训练得到模型trained_model
y=test(trained_model,x=100) # 得到半径为100的圆的面积

简单解释

learn() 函数的具体实现暂且不提，它的作用是，会使用通过数据 data 训练模型 model ，当我们需要计算一个新的圆的面积时，就调用 test 函数，根据训练好的模型去计算其面积。
这里先把 learn() 视作黑盒子，我们不需要事先知道输入和输出之间的关系，也不需要手动设置任何参数，只要把数据 “喂给” 学习算法 learn , 它就会自动得出一个能够解决问题的模型。
在训练过程中，模型 model 其实是 “学习” 到了输入和输出之前的关系以及相关的参数。就像是一个数学家通过对圆的观察，得出了圆的面积和半径的关系，并且求出了圆周率

这就引出机器学习的基本部分

用来解决问题的模型model
学习数据（或者说训练数据）data
让模型model通过数据data学会解决特定问题的学习算法learn
用来纠正模型的test方法

学习算法的几个基本概念

回归问题与分类问题

回归(regression): 例如机器学会计算圆形面积的例子属于回归问题。即我们的目的是对于一个输入 x，预测其输出值 y，且这个 y 值是根据 x 连续变化的值。
分类(classification): 事先给定若干个类别，对于一个输入 x，判断其属于哪个类别，即输出一般是离散的。比如图片英文字母识别。

有监督学习与无监督学习

有监督学习，即在训练过程中，输入x得出y，而这个y的正确答案也事先准备好，用来纠正模型。
无监督学习，没有事先准备正确答案，一般用于聚类(cluster)问题，即给定一批数据，根据这批数据的特点，将其分为多个类别，虽然我并不知道这每个类别所代表的具体含义。
- 这一点特别有趣，可以从大数据中发现人直觉难以察觉的信息，当中可能蕴含极大价值。
- 比如网络商城的商品推荐算法可能会根据用户的使用习惯，以往的浏览历史等，将用户分为多个类别，同一类别的用户在行为模式上可能比较相似。而事先并不知道最终会划分出多少个类别，每个类别有哪些共同特点。

一种重要的模型——神经网络

线性方程组

简单解释

上图中网络层１与网络层２的节点，称作神经元，a与b的连接，有笛卡尓积（直积）的条数，即〈x，y〉(x∈a，y∈b)的a×b的交集。它们的连接的数学关系，如下

a1*w11 + a2*w12 + a3*w13 + bias1 = b1
a1*w21 + a2*w22 + a3*w23 + bias2 = b2

这是一个线性方程组

a, b 神经元，从数学上看，是一个值
w 权重
bias 偏移量

写成矩阵的形式：

对于网络层2中的神经元b，它的值在传给输出之前, 会先经过一次非线性运算g，这个g称为激活函数

g(b1)=Y1  
g(b2)=Y2

ps: 方程求导后是常数的是线性方程，否则是非线性方程

非线性的激活函数

实际运用当中，有多种激活函数可以选择，这里我们介绍最经典的一种激活函数： sigmoid 激活函数，它的数学形式为：

sigmoid 函数图像是

即输入值x越大，函数值越接近 1，输入值越小，函数值越接近 0，当输入为 0 的时候，函数值为 0.5。

上面是一个激活函数的例子，为什么使用非线性的激活函数呢？原因有几个：

多层网络的意义

深度神经网络是多层神经网络，如果没有非线性运算部分，由于 矩阵乘法的结合性，我们简算方程式后，多个线性运算层最终会简化成一个线性运算，多层次的网络结构失去了意义。

非线性分类更贴近实际

实际上，不同类别之间的分界线更多是曲线而不是直线，此时无论如何也无法用线性分类器去准确的进行分类。而非线性部分的引入，在一定程度上可以使原本的直线变成曲线。

当输入数据的维度为 3 时，单纯的线性运算就相当于是使用一个平面对空间进行划分，当数据维度高于 3 维时类似，只是我们已经无法直观的观察大于 3 维的空间了。

概率

非线性激活函数还有其他作用，比如sigmoid将输出值的范围限制在 0 到 1 之间，使其刚好可以被作为概率来看待。

评价神经网络的效果

如何设定神经网络中的网络参数值（包括连接线上的权重w和偏置值bias）。

一种最简单的方法是随机设定网络参数。如果神经网络中的网络参数是随机设置的，那么我们得到的 “网络性能” 应该就是随机情况下的平均值。比如我们要判断一些图片中的字母属于 26 个字母中的哪一个，如果网络参数值是随机设定的话，那我们得到的识别准确率理论上应该在 1/26 左右。随机设定参数值当然不可能是我们解决问题的办法。
如何设置 “好” 的网络参数值来使神经网络正确的工作，这是 网络性能 的问题。我们如何判定一个神经网络是 “好” 的还是 “不好” 的呢，即我们用什么来评价一个神经网络的效果呢？

损失函数

在有监督学习中，学习数据 data 包含输入数据的预期正确输出值，一个简单的办法是比较神经网络的输出 h 与预期的正确输出 y 之间的差异。比如计算(h-y)^2, 当得到的值比较大时，就说明我们的神经网络的输出与预期的正确输出偏差较大，反之，如果得到的值很小甚至等于 0，就说明我们的模型工作的不错，能够正确的预测输出值。

二次损失函数 quadratic loss

就像它的名字所暗示的那样，quadratic loss function 通过计算h和y之间差值的二次方，来表达一个神经网络的效果。具体形式如下：

学习算法learn按照某种策略，通过不断的更新参数值来使损失函数 J(theta,X,Y) 的值减小，theta 是自变量。
上面公式J(theta,X,Y), 从训练算法的角度看，我们要训练的算法是 J(theta)，因为对于一个特定的问题来讲，输入 X 与输出 Y 可以视作常量。

梯度下降算法

衡量神经网络性能的办法:损失函数，训练算法是，就必须想办法让损失函数的值尽量小，最好是让损失函数值为0。

假设我们的损失函数图形是这样的：

我们的目标是使A尽量靠近最低点B, 最好是与B重合，这样才能最小化损失函数。

梯度

梯度是一个向量，由损失函数对每个自变量（图中的 theta0 和 theta1）分别求偏导得到。

形象的理解，梯度指向损失函数变化最快的那个方向（且该方向让函数值变大），在图中的三维上，就是曲面上在 A 点最 “陡峭” 的方向。在二维上，是斜率方向。

梯度下降算法

上图中，梯度的方向使损失函数的值变大，于是为了使 A 点向 B 点移动，就可以对 A 的值减去该点的梯度（alpha * 斜率）。
上面公式有一个希腊字母alpha，梯度表示更新参数 theta 的方向，而这个 alpha 表示往这个方向走多远。
当走到下一个位置之后，再求该点的梯度，用梯度更新参数位置，如此重复，直到逼近 B 点。这就是梯度下降算法的原理。
alpha 在这里是一个超参数（hyperparameter）

ps: 实际中，损失函数并不像图中的凸函数那么理想，梯度下降算法可能无法到达最低点，或者被“局部最低点”（梯度为0）欺骗而无法到达“全局最低点”。需要采取一些方法，暂不提。

参数 (parameter) 与超参数(hyper parameter)

模型 model 中的参数 theta 称为参数，而学习算法（即梯度下降算法）里的参数 alhpa 被称为超参数。它们区别在于：

theta 被称为 “参数”，它决定了模型 model 的性质，最终值是由学习算法 learn 学习得到，不需要手工设定。
alhpa 是学习算法 learn 中决定梯度下降算法每一步走多远的参数，它需要手工设定，决定了得到最优theta的过程。即超参数决定如何得到最优参数。

ps: 复杂问题的模型中可能有上亿个参数，这都由学习算法得到，而我们只需手动设置超参数。

超参数 alpha– 学习速率

机器学习中，我们将上面提到的超参数alpha称为学习速率（learning rate）。这很好理解，因为alpha越大时，我们的参数theta更新的幅度越大，我们可能会更快的到达最低点。但是alpha不能设置的太大，否则有可能一次变化的太大导致 “步子太长”，会直接越过最低点，甚至导致损失函数值不降反升。

思考题

“手工编程计算圆的面积”中，3.14 是 “参数” 还是“超参数”？

答：参数

一个如本次实验所描述的神经网络有两层，第一层有 10 个神经元，第二层有 20 个神经元，请问这两层神经元之间有多少条连接？第一层到第二层之间由这些连接所表示的线性变换矩阵尺寸是多少？

答：笛卡尓积，10*20=200 条连接。这些连接表示的矩阵，尺寸是：10列×20行

“使用深度学习预测股票走势曲线” 是分类问题还是回归问题？

答：回归

“根据人脸图片识别人的性别” 是分类问题还是回归问题？

答：分类

如果说，有监督学习的训练数据data由输入X和正确答案Y组成，那无监督学习的训练数据应该是什么样的？

答：-

sigmoid 函数对 x 求导结果是什么？

答：

求导过程

“超参数 alpha– 学习速率” 小节中的图片里，为什么 “学习速率适中” 图中每次更新的 “步子” 越来越短，而 “学习速率过大” 图中每次更新的 “步子” 越来越长？

答：学习速率过大，导致梯度的斜率越来越 “陡峭”，越陡峭的斜率乘以过大的 alpha ，得到的 theta 偏移量越来越大。

你能自己想出一种求损失函数梯度的方法吗？

答：-

golang工程实践——Makefile的技巧之标记编译信息

Sun, 19 Aug 2018 14:30:00 +0000

前言
技巧列表
- 给二进制包标记时间戳与源码版本号
  - 原理解释

前言

Golang 的程序编译安装，如果善加使用 Makefile 文件，可以使开发过程更规范与高效，比如：

１、给编译的二进制文件“标记上”时间戳与源码版本号，方便程序更新与错误追溯。

２、开发时，监视文件修改，自动编译，执行测试用例，提高工作效率。

等等。。。

技巧列表

给二进制包标记时间戳与源码版本号

1、在 golang 代码中加入以下代码

package main

import (
	"fmt"
	"os"
)

// build info
var (
    BuildTime          = ""
    ProgramCommitID    = ""
	GoVersion          = ""
)

func init() {
	if len(os.Args) == 2 && (os.Args[1] == "-v" || os.Args[1] == "-version") {
		fmt.Println("go version: \t" + GoVersion) // \t 为 Tab 符号
		fmt.Println("Build Time: \t" + BuildTime)
		fmt.Println("Program Commit ID : \t" + ProgramCommitID)
		os.Exit(1)
	}
}

2、在 Makefile 执行编译的语句中加入常量：

# 默认在项目的根目录下执行 Makefile
GO_VERSION=$(shell go version)
BUILD_TIME=$(shell date +%F-%Z/%T)
ProgramCommitID=$(shell git rev-parse HEAD) # 项目是 Git 版本控制，则获取当前 commit id

LDFLAGS=-ldflags "-X 'main.GoVersion=${GO_VERSION}' -X main.BuildTime=${BUILD_TIME} -X main.ProgramCommitID=${ProgramCommitID}"

all:
	go build ${LDFLAGS} -v

３、以上代码加入任意项目中，成功编译后，比如可执行文件名为”executable”，这样执行 executable -v，会打印信息如下：

go version:     go version go1.11.1 linux/amd64
Build Time:     2018-10-29-CST/19:46:16
Program Commit ID :         53df91aeb41bef38530bdd5a5ebc4f334331a9bf

原理解释

1、LDFLAGS是链接选项，-X 表示在编译时给变量赋值，通过 Makefile 中添加命令就可以灵活地给程序中的变量赋值。 2、golang 的 main 包的 init 函数是 golang 程序初始化阶段最后执行的一个 init 函数，上面代码的 init 函数执行完毕就 os.Exit(1) 推出，不会执行到 main 包的 main 主函数，这样，我们可以 executable -v 执行后查看程序包的信息后，关闭程序。

架构思考-代理服务与负载均衡算法

Sun, 19 Aug 2018 12:30:00 +0000

前言

前言

就是同一个服务要部署多个节点，然后一个请求任务过来，那么这个请求分发给哪个服务呢

工程的优化演进

1、最简单的循环调用

2、按人工标记的权重轮询

3、用指数加权移动平均来预测服务延迟曲线，把请求分发给延迟最小的服务节点

EWMA exponentially weighted moving average

https://blog.buoyant.io/2016/03/16/beyond-round-robin-load-balancing-for-latency/

预测服务各节点的延时，并与未完成请求数加权，再选择消耗成本最低的服务节点

因为每台机器的性能不同，简单的 round robin 只是平均的把服务丢到各个服务，或者统计每个节点未完成请求数，选择最小那个。

如果加上EWMA预测延时的算法，就更好做负载均衡了

避免了人工标记权重的主观性（像 nignx 的 weight round robin），由算法来预测各个节点的延时曲线，在不同机器性能与网络带来负载能力差异下，更有针对性的分发请求到各个节点

【我做翻译】一个好的 Go 语言 Makefile 是怎样的

Thu, 09 Aug 2018 12:30:00 +0000

我做翻译
前言
- 1、一步一步开始
- 终极版本

我做翻译

这是我参与社区翻译小组的一篇译文

前言

精简的 Makefile，用于简化构建和管理用 Go 编写的 Web 服务器。

我偶然调整我的 Makefiles 来加快我的开发过程，一天早上有点时间，我决定与大家分享其中诀窍。

总而言之，我使用 Go 构建 Web 服务器，我对 Makefile 的期望如下：

高级，简单的命令。比如：compile start stop watch 等等
管理具体项目环境的变量，它应该包含 .env 文件
开发模式，修改时自动编译
开发模式，修改时自动重启服务
开发模式，简洁地显示编译的错误信息
具体项目的 GOPATH，以使我可以在 vendor 目录维护依赖包
简化文件查看，比如 make watch run="go test ./..."

下面是我偏爱的文件目录布局：

.env
Makefile
main.go
bin/
src/
vendor/

在此文件结构中键入 make 命令将提供以下输出：

$ make

Choose a command run in my-web-server:

install   Install missing dependencies. Runs `go get` internally.
start     Start in development mode. Auto-starts when code changes.
stop      Stop development mode.
compile   Compile the binary.
watch     Run given command when code changes. e.g; make watch run="go test ./..."
exec      Run given command, wrapped with custom GOPATH. e.g; make exec run="go test ./..."
clean     Clean build files. Runs `go clean` internally.

1、一步一步开始

环境变量

首先，我们希望在 Makefile 中 include 我们为项目定义的环境变量，所以，第一行如下：

include .env

在具体项目的环境变量文件的头部，我们将定义这些：项目名，Go 目录/文件，进程 id 的路径…

PROJECTNAME=$(shell basename "$(PWD)")

# Go related variables.
GOBASE=$(shell pwd)
GOPATH=$(GOBASE)/vendor:$(GOBASE)
GOBIN=$(GOBASE)/bin
GOFILES=$(wildcard *.go)

# Redirect error output to a file, so we can show it in development mode.
STDERR=/tmp/.$(PROJECTNAME)-stderr.txt

# PID file will store the server process id when it's running on development mode
PID=/tmp/.$(PROJECTNAME)-api-server.pid

# Make is verbose in Linux. Make it silent.
MAKEFLAGS += --silent

在 Makefile 文件的其余部分，我们将使用特别的 GOPATH 变量。我们所有的命令都应该包含项目特定的 GOPATH，否则它们将无法工作。这为我们的 Go 项目提供了明确的隔离，并带来了一些复杂性。为了简化操作，我们可以添加一个 exec 命令，该命令执行任何给定的命令，并使用上面定义的自定义 GOPATH。

## exec: Run given command, wrapped with custom GOPATH. e.g; make exec run="go test ./..."
exec:
	@GOPATH=$(GOPATH) GOBIN=$(GOBIN) $(run)

但这并不是很高级的做法。我们应该用简单的命令来介绍一些常见的情况，如果我们正在做 Makefile 未涵盖的事情，那么只能使用 exec 。

开发模式

开发模式应该是这样：

清空构建缓存
编译代码
后台执行服务
当代码被修改时，重复上面步骤

这听起来很简单，但很快变得复杂，我们将同时运行服务器和文件观察程序。我们需要确保在开始新流程之前正确停止服务，并且也不会破坏常见的命令行行为，例如在按下 Control-C 或 Control-D 时停止。

start:
	bash -c "trap 'make stop' EXIT; $(MAKE) compile start-server watch run='make compile start-server'"

stop: stop-server

下面是代码解决的问题：

后台编译与执行服务
主进程不在后台执行，我们可以随时使用 Control-C 中断它
当主进程中断时，停止后台进程，为此，我们需要 trap
当代码修改时，重新编译与重启服务

在下一节中，我将详细解释这些命令

编译

compile 命令不仅仅是在后台调用 go compile ; 它还清理错误输出并打印简化版本。

以下是在命令行中进行重大更改的方法：

compile:
	@-touch $(STDERR)
	@-rm $(STDERR)
	@-$(MAKE) -s go-compile 2> $(STDERR)
	@cat $(STDERR) | sed -e '1s/.*/\nError:\n/'  | sed 's/make\[.*/ /' | sed "/^/s/^/     /" 1>&2

开启/停止服务

start-server 基本上运行它在后台编译的二进制文件，将其 PID 保存到临时文件中。

stop-server 读取 PID 并在需要时终止进程。

start-server:
	@echo "  >  $(PROJECTNAME) is available at $(ADDR)"
	@-$(GOBIN)/$(PROJECTNAME) 2>&1 & echo $$! > $(PID)
	@cat $(PID) | sed "/^/s/^/  \>  PID: /"

stop-server:
	@-touch $(PID)
	@-kill `cat $(PID)` 2> /dev/null || true
	@-rm $(PID)

restart-server: stop-server start-server

观察变化

我们需要一个文件观察器来观察变化。我尝试了很多并且感到不满意，所以最终创建了我自己的文件观察工具 yolo 。通过下面命令安装在您的系统中

$  go get github.com/azer/yolo

一旦安装完毕，我们基本上可以开始观察项目目录中的更改，排除像 vendor 或者 bin 这样的目录，如下：

## watch: Run given command when code changes. e.g; make watch run="echo 'hey'"
watch:
	@yolo -i . -e vendor -e bin -c $(run)

现在我们得到一个 watch 命令，它在项目目录中以递归方式监视更改，不包括 vendor 目录。我们可以直接传递我们想要的任何运行命令。例如，start 命令基本上在代码更改时调用 make compile start-server：

make watch run="make compile start-server"

我们可以用它来运行测试，或自动检查是否有任何竞争条件。将为执行设置环境变量，因此您根本不必担心 GOPATH：

make watch run="go test ./..."

关于 Yolo 的一个好处是它的网络界面。如果启用它，您可以立即在 Web 界面中看到命令的输出。您只需要传递 -a 选项来启用它：

yolo -i . -e vendor -e bin -c "go run foobar.go" -a localhost:9001

然后，您可以在浏览器中打开 localhost:9001 并立即开始在浏览器中查看结果：

安装依赖

当我们在代码中进行更改时，我们希望在编译之前下载缺少的依赖项。install 命令将为我们完成这项工作;

install: go-get

我们在文件改动时，编译之前自动调用 install , 让依赖包可以自动安装，如果您想手动安装依赖项，你可以执行:

make install get="github.com/foo/bar"

在内部，这个命令会转换成：

$ GOPATH=~/my-web-server GOBIN=~/my-web-server/bin go get github.com/foo/bar

它是如何工作的？请参阅下一节，我们实际添加了用于实现更高级别命令的 Go 命令。

Go 命令

如果我们想设置 GOPATH 到项目的目录，简化依赖管理（在 Go 生态中还没正式解决的问题），就需要在 Makefile 中封装 Go 命令。

go-compile: go-clean go-get go-build

go-build:
	@echo "  >  Building binary..."
	@GOPATH=$(GOPATH) GOBIN=$(GOBIN) go build -o $(GOBIN)/$(PROJECTNAME) $(GOFILES)

go-generate:
	@echo "  >  Generating dependency files..."
	@GOPATH=$(GOPATH) GOBIN=$(GOBIN) go generate $(generate)

go-get:
	@echo "  >  Checking if there is any missing dependencies..."
	@GOPATH=$(GOPATH) GOBIN=$(GOBIN) go get $(get)

go-install:
	@GOPATH=$(GOPATH) GOBIN=$(GOBIN) go install $(GOFILES)

go-clean:
	@echo "  >  Cleaning build cache"
	@GOPATH=$(GOPATH) GOBIN=$(GOBIN) go clean

帮助

最后，我们需要一个 help 命令来查看可用命令的概述。我们可以使用自动生成优雅的格式的命令 sed 与 column ，如下：

help: Makefile
	@echo " Choose a command run in "$(PROJECTNAME)":"
	@sed -n 's/^##//p' $< | column -t -s ':' |  sed -e 's/^/ /'

这个命令会基本地扫描 Makefile 中以 ## 开头的文本行并输出它们。所以，你可以简单的注释你所定义的命令，这些命令会被 help 命令打印出来。

比如我们添加如下的注释：

## install: Install missing dependencies. Runs `go get` internally.
install: go-get

## start: Start in development mode. Auto-starts when code changes.
start:

## stop: Stop development mode.
stop: stop-server

我们可以执行：

$ make help

Choose a command run in my-web-server:

install   Install missing dependencies. Runs `go get` internally.
start     Start in development mode. Auto-starts when code changes.
stop      Stop development mode.

终极版本

以下是我在上面分享的所有组合和终极版本。这是我今天早上开始的一个新项目的完美副本：

include .env

PROJECTNAME=$(shell basename "$(PWD)")

# Go related variables.
GOBASE=$(shell pwd)
GOPATH="$(GOBASE)/vendor:$(GOBASE)
GOBIN=$(GOBASE)/bin
GOFILES=$(wildcard *.go)

# Redirect error output to a file, so we can show it in development mode.
STDERR=/tmp/.$(PROJECTNAME)-stderr.txt

# PID file will keep the process id of the server
PID=/tmp/.$(PROJECTNAME).pid

# Make is verbose in Linux. Make it silent.
MAKEFLAGS += --silent

## install: Install missing dependencies. Runs `go get` internally. e.g; make install get=github.com/foo/bar
install: go-get

## start: Start in development mode. Auto-starts when code changes.
start:
    bash -c "trap 'make stop' EXIT; $(MAKE) compile start-server watch run='make compile start-server'"

## stop: Stop development mode.
stop: stop-server

start-server: stop-server
	@echo "  >  $(PROJECTNAME) is available at $(ADDR)"
	@-$(GOBIN)/$(PROJECTNAME) 2>&1 & echo $$! > $(PID)
	@cat $(PID) | sed "/^/s/^/  \>  PID: /"

stop-server:
	@-touch $(PID)
	@-kill `cat $(PID)` 2> /dev/null || true
	@-rm $(PID)

## watch: Run given command when code changes. e.g; make watch run="echo 'hey'"
watch:
	@GOPATH=$(GOPATH) GOBIN=$(GOBIN) yolo -i . -e vendor -e bin -c "$(run)"

restart-server: stop-server start-server

## compile: Compile the binary.
compile:
	@-touch $(STDERR)
	@-rm $(STDERR)
	@-$(MAKE) -s go-compile 2> $(STDERR)
	@cat $(STDERR) | sed -e '1s/.*/\nError:\n/'  | sed 's/make\[.*/ /' | sed "/^/s/^/     /" 1>&2

## exec: Run given command, wrapped with custom GOPATH. e.g; make exec run="go test ./..."
exec:
	@GOPATH=$(GOPATH) GOBIN=$(GOBIN) $(run)

## clean: Clean build files. Runs `go clean` internally.
clean:
	@(MAKEFILE) go-clean

go-compile: go-clean go-get go-build

go-build:
	@echo "  >  Building binary..."
	@GOPATH=$(GOPATH) GOBIN=$(GOBIN) go build -o $(GOBIN)/$(PROJECTNAME) $(GOFILES)

go-generate:
	@echo "  >  Generating dependency files..."
	@GOPATH=$(GOPATH) GOBIN=$(GOBIN) go generate $(generate)

go-get:
	@echo "  >  Checking if there is any missing dependencies..."
	@GOPATH=$(GOPATH) GOBIN=$(GOBIN) go get $(get)

go-install:
	@GOPATH=$(GOPATH) GOBIN=$(GOBIN) go install $(GOFILES)

go-clean:
	@echo "  >  Cleaning build cache"
	@GOPATH=$(GOPATH) GOBIN=$(GOBIN) go clean

.PHONY: help
all: help
help: Makefile
	@echo
	@echo " Choose a command run in "$(PROJECTNAME)":"
	@echo
	@sed -n 's/^##//p' $< | column -t -s ':' |  sed -e 's/^/ /'
	@echo

就是这样！如果您有任何问题，想法或一些建议，以使其更好，请给我发电子邮件！

干杯！

via: http://azer.bike/journal/a-good-makefile-for-go/

作者：Azer Koçulu 译者：lightfish-zhang 校对：polaris1119

本文由 GCTT 原创编译，Go 中文网荣誉推出

【我做翻译】Go 语言的 append 不总是线程安全的

Wed, 18 Jul 2018 12:30:00 +0000

我做翻译
示例问题
解释为什么测试失败
这个 bug 的认知根源
认知这个 bug
解决方法

我做翻译

这是我参与社区翻译小组的一篇译文

示例问题

我经常看到一些 bug 是由于没有在线程安全下在 slice 上进行 append 而引起的。下面用单元测试来举一个简单的例子。这个测试有两个协程对相同的 slice 进行 append 操作。如果你使用 -race flag 来执行这个单元测试，效果更好。

package main

import (
	"sync"
	"testing"
)

func TestAppend(t *testing.T) {
	x := []string{"start"}

	wg := sync.WaitGroup{}
	wg.Add(2)
	go func() {
		defer wg.Done()
		y := append(x, "hello", "world")
		t.Log(cap(y), len(y))
	}()
	go func() {
		defer wg.Done()
		z := append(x, "goodbye", "bob")
		t.Log(cap(z), len(z))
	}()
	wg.Wait()
}

现在，让我们稍微修改代码，以给这个名为 x 的 slice 在创建是预留一些容量。唯一改动的地方是第 9 行。

package main

import (
	"testing"
	"sync"
)

func TestAppend(t *testing.T) {
	x := make([]string, 0, 6)

	wg := sync.WaitGroup{}
	wg.Add(2)
	go func() {
		defer wg.Done()
		y := append(x, "hello", "world")
		t.Log(len(y))
	}()
	go func() {
		defer wg.Done()
		z := append(x, "goodbye", "bob")
		t.Log(len(z))
	}()
	wg.Wait()
}

如果我们执行这个测试时带上 -race flag ，我们可以注意到一个竞争条件。

< go test -race .
==================
WARNING: DATA RACE
Write at 0x00c4200be060 by goroutine 8:
_/tmp.TestAppend.func2()
/tmp/main_test.go:20 +0xcb
Previous write at 0x00c4200be060 by goroutine 7:
_/tmp.TestAppend.func1()
/tmp/main_test.go:15 +0xcb
Goroutine 8 (running) created at:
_/tmp.TestAppend()
/tmp/main_test.go:18 +0x14f
testing.tRunner()
/usr/local/Cellar/go/1.10.2/libexec/src/testing/testing.go:777 +0x16d
Goroutine 7 (running) created at:
_/tmp.TestAppend()
/tmp/main_test.go:13 +0x105
testing.tRunner()
/usr/local/Cellar/go/1.10.2/libexec/src/testing/testing.go:777 +0x16d
==================
==================
WARNING: DATA RACE
Write at 0x00c4200be070 by goroutine 8:
_/tmp.TestAppend.func2()
/tmp/main_test.go:20 +0x11a
Previous write at 0x00c4200be070 by goroutine 7:
_/tmp.TestAppend.func1()
/tmp/main_test.go:15 +0x11a
Goroutine 8 (running) created at:
_/tmp.TestAppend()
/tmp/main_test.go:18 +0x14f
testing.tRunner()
/usr/local/Cellar/go/1.10.2/libexec/src/testing/testing.go:777 +0x16d
Goroutine 7 (finished) created at:
_/tmp.TestAppend()
/tmp/main_test.go:13 +0x105
testing.tRunner()
/usr/local/Cellar/go/1.10.2/libexec/src/testing/testing.go:777 +0x16d
==================
--- FAIL: TestAppend (0.00s)
main_test.go:16: 2
main_test.go:21: 2
testing.go:730: race detected during execution of test
FAIL
FAIL _/tmp 0.901s

解释为什么测试失败

理解为什么这个失败会发生，请看看这个旧例子的 x 的内存布局

x 没有足够的容量进行修改

Go 语言发现没有足够的内存空间来存储 "hello", "world" 和　"goodbye", "bob"，于是分配的新的内存给 y 与 z。数据竞争不会在多进程读取内存时发生，x 没有被修改。这里没有冲突，也就没有竞争。

z 与 y 获取新的内存空间

在新的代码里，事情不一样了

x 有更多的容量

在这里，go 注意到有足够的内存存放 “hello”, “world”，另一个协程也发现有足够的空间存放 “goodbye”, “bob”，这个竞争的发生是因为这两个协程都尝试往同一个内存空间写入，谁也不知道谁是赢家。

谁赢了？

这是 Go 语言的一个特性而非 bug ，append 不会强制每一次调用它都申请新的内存。它允许用户在循环内进行 append 操作时不会破坏垃圾回收机制。缺点是你必须清楚知道在多个协程对 slice 的操作。

这个 bug 的认知根源

我相信这个 bug 存在是 Go 的为了保存简单，将许多概念放到 slice 中，在大多数开发人员中看到的思维过程是：

x=append(x, ...) 看起来你要获得一个新的 slice。
大多数返回值的函数都不会改变它们的输入。
我们使用 append 通常都是得到一个新的 slice。
错误地认为append是只读的。

认知这个 bug

值得注意的是如果第一个被 append 的变量不是一个本地变量（译者：本地变量，即变量与 append 在同一代码块）。这个 bug 通常发生在：进行 append 操作的变量存在一个结构体中，而这个结构体是通过函数传参进来的。例如，一个结构体可以有默认值，可以被各个请求 append。小心对共享内存的变量进行 append ，或者这个内存空间（变量）并不是当前协程独占的。

解决方法

最简单的解决方法是不使用共享状态的第一个变量来进行 append 。相反，根据你的需要来 make 一个新的 slice ，使用这个新的 slice 作为 append 的第一个变量。下面是失败的测试示例的修正版，这里的替代方法是使用 copy 。

package main

import (
	"sync"
	"testing"
)

func TestAppend(t *testing.T) {
	x := make([]string, 0, 6)
	x = append(x, "start")

	wg := sync.WaitGroup{}
	wg.Add(2)
	go func() {
		defer wg.Done()
		y := make([]string, 0, len(x)+2)
		y = append(y, x...)
		y = append(y, "hello", "world")
		t.Log(cap(y), len(y), y[0])
	}()
	go func() {
		defer wg.Done()
		z := make([]string, 0, len(x)+2)
		z = append(z, x...)
		z = append(z, "goodbye", "bob")
		t.Log(cap(z), len(z), z[0])
	}()
	wg.Wait()
}

对本地变量进行第一次的 append

via: https://medium.com/@cep21/gos-append-is-not-always-thread-safe-a3034db7975

作者：Jack Lindamood 译者：lightfish-zhang 校对：polaris1119

本文由 GCTT 原创编译，Go 中文网荣誉推出