for i := range streamMap {
            go func(i int) {
                err := pushStream(que, streamMap[i], wait)
                if err != nil {
                    log.Println(err)
                }

            }(i)
        }

        for i := range streamMap {
            wait.Add(1)
            go func(i int) {
                err := pushStream(que, streamMap[i], wait)
                if err != nil {
                    log.Println(err)
                }
            }(i)
        }

package main

import (
    "log"
    "strings"
    "sync"

    "github.com/nareix/joy4/av/avutil"
    "github.com/nareix/joy4/av/pubsub"
    "github.com/nareix/joy4/format"
    "github.com/nareix/joy4/format/rtmp"

)

func init() {
    format.RegisterAll()
    log.SetFlags(log.Lshortfile|log.Ltime)
}

var sm = map[string][]string{
    "azorestv": []string{"rtmp://opinion.azorestv.com:1936/live/test"},
}

func main() {
    proxyServer()
}

func proxyServer() {
    server := &rtmp.Server{}
    //rtmp.Debug=true

    server.HandlePublish = func(conn *rtmp.Conn) {

        segs := strings.Split(conn.URL.Path, "/")

        key := segs[2]
        streamMap, ok := sm[key]
        if !ok {
            log.Println("invalid key")
            return
        }

        que := &pubsub.Queue{}

        streams, err := conn.Streams()
        if err != nil {
            log.Println(err)
            return
        }

        que = pubsub.NewQueue(streams)

        wait := &sync.WaitGroup{}

        for i := range streamMap {
            wait.Add(1)
            go func(i int,que *pubsub.Queue,wait *sync.WaitGroup) {
                err := pushStream(que, streamMap[i], wait)
                if err != nil {
                    log.Println(err)
                }
            }(i,que,wait)
        }

        go avutil.CopyPackets(que, conn)

        wait.Wait()
    }

    server.ListenAndServe()

}

func pushStream(sub *pubsub.Queue, dsturl string, wait *sync.WaitGroup) error {
    defer wait.Done()

    origin := sub.Latest()

    dst, err := rtmp.Dial(dsturl)
    if err != nil {
        return err
    }

    defer dst.Close()

    return avutil.CopyFile(dst, origin)
}