file.go

   1 package anidb
   2
   3 import (
   4         "encoding/json"
   5         "fmt"
   6         "github.com/Kovensky/go-anidb/misc"
   7         "image"
   8         "strconv"
   9         "time"
  10 )
  11
  12 type FileVersion int
  13
  14 func (v FileVersion) String() string {
  15         if v == 1 {
  16                 return ""
  17         }
  18         return fmt.Sprintf("v%d", int(v))
  19 }
  20
  21 type FileSource string
  22
  23 type AudioStream struct {
  24         Codec    string
  25         Bitrate  int
  26         Language Language
  27 }
  28
  29 type VideoInfo struct {
  30         Codec      string
  31         Bitrate    int
  32         Resolution image.Rectangle
  33         ColorDepth int
  34 }
  35
  36 type File struct {
  37         FID FID
  38
  39         AID AID
  40         EID EID
  41         GID GID
  42         LID LIDMap
  43
  44         EpisodeNumber misc.EpisodeList
  45
  46         Incomplete bool
  47
  48         Deprecated bool
  49         CRCMatch   bool
  50         BadCRC     bool
  51         Version    FileVersion
  52         Uncensored bool // Meaning unclear, may not be simply !Censored
  53         Censored   bool // Meaning unclear, may not be simply !Uncensored
  54
  55         Filesize int64
  56         Ed2kHash string
  57         SHA1Hash string
  58         CRC32    string
  59
  60         Length  time.Duration
  61         AirDate time.Time
  62
  63         AudioStreams      []AudioStream
  64         SubtitleLanguages []Language
  65         VideoInfo         VideoInfo
  66         FileExtension     string
  67
  68         Source FileSource
  69
  70         // Map of related EIDs to percentages (range 0.0-1.0).
  71         // The percentage indicates how much of the EID is covered by this file.
  72         RelatedEpisodes RelatedEpisodes
  73
  74         Cached time.Time
  75 }
  76
  77 type RelatedEpisodes map[EID]float32
  78
  79 func (er RelatedEpisodes) MarshalJSON() ([]byte, error) {
  80         generic := make(map[string]float32, len(er))
  81         for k, v := range er {
  82                 generic[strconv.Itoa(int(k))] = v
  83         }
  84         return json.Marshal(generic)
  85 }
  86
  87 func (er RelatedEpisodes) UnmarshalJSON(b []byte) error {
  88         var generic map[string]float32
  89         if err := json.Unmarshal(b, &generic); err != nil {
  90                 return err
  91         }
  92         for k, v := range generic {
  93                 ik, err := strconv.ParseInt(k, 10, 32)
  94                 if err != nil {
  95                         return err
  96                 }
  97
  98                 er[EID(ik)] = v
  99         }
 100
 101         return nil
 102 }
 103
 104 type LIDMap map[UID]LID
 105
 106 func (m LIDMap) MarshalJSON() ([]byte, error) {
 107         generic := make(map[string]int, len(m))
 108         for k, v := range m {
 109                 generic[strconv.Itoa(int(k))] = int(v)
 110         }
 111         return json.Marshal(generic)
 112 }
 113
 114 func (m LIDMap) UnmarshalJSON(b []byte) error {
 115         var generic map[string]int
 116         if err := json.Unmarshal(b, &generic); err != nil {
 117                 return err
 118         }
 119         for k, v := range generic {
 120                 ik, err := strconv.ParseInt(k, 10, 32)
 121                 if err != nil {
 122                         return err
 123                 }
 124
 125                 m[UID(ik)] = LID(v)
 126         }
 127
 128         return nil
 129 }